use istio client-go library instead of knative (#1661)

use istio client-go library instead of knative
bump kubernetes dependency version
change code coverage to codecov

.gitignore

@@ -28,5 +28,7 @@ apiserver.local.config
 .DS_Store
 api.json
 *.coverprofile
+cover.out
+coverage.txt
 
-kustomize/network/etcd
\ No newline at end of file
+kustomize/network/etcd

.travis.yml

@@ -10,6 +10,7 @@ git:
 
 go:
   - "1.12.x"
+  - "tip"
 env:
   - GO111MODULE=on
 cache:
@@ -23,11 +24,13 @@ before_script:
 script:
   - diff -u <(echo -n) <(gofmt -d ./pkg ./cmd ./tools)
   - make openapi
-  - make all && $HOME/gopath/bin/goveralls -coverprofile=cover.out -service=travis-ci -repotoken=$COVERALLS_TOKEN
+  - make all 
 
-install:
-  - go get golang.org/x/tools/cmd/cover
-  - go get github.com/mattn/goveralls
+before_install:
+  - go get -t -v ./...
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
 
 deploy:
   skip_cleanup: true

Makefile

@@ -98,7 +98,7 @@ docker-build: all
 
 # Run tests
 test: fmt vet
-	export KUBEBUILDER_CONTROLPLANE_START_TIMEOUT=1m; go test -v ./pkg/... ./cmd/... -covermode=count -coverprofile cover.out
+	export KUBEBUILDER_CONTROLPLANE_START_TIMEOUT=1m; go test ./pkg/... ./cmd/... -covermode=atomic -coverprofile=coverage.txt
 
 .PHONY: clean
 clean:

api/api-rules/violation_exceptions.list

+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIGroup,ServerAddressByClientCIDRs
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIGroup,Versions
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIGroupList,Groups
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIResource,Categories
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIResource,ShortNames
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIResourceList,APIResources
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIVersions,ServerAddressByClientCIDRs
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,APIVersions,Versions
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,CreateOptions,DryRun
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,DeleteOptions,DryRun
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,FieldsV1,Raw
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,LabelSelector,MatchExpressions
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,LabelSelectorRequirement,Values
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,List,Items
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,ObjectMeta,Finalizers
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,ObjectMeta,ManagedFields
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,ObjectMeta,OwnerReferences
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,PartialObjectMetadataList,Items
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,PatchOptions,DryRun
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,RootPaths,Paths
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,StatusDetails,Causes
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,Table,ColumnDefinitions
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,Table,Rows
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,TableRow,Cells
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,TableRow,Conditions
+API rule violation: list_type_missing,k8s.io/apimachinery/pkg/apis/meta/v1,UpdateOptions,DryRun
+API rule violation: list_type_missing,kubesphere.io/kubesphere/pkg/apis/devops/v1alpha1,S2iBinaryList,Items
 API rule violation: names_match,k8s.io/apimachinery/pkg/apis/meta/v1,APIResourceList,APIResources
 API rule violation: names_match,k8s.io/apimachinery/pkg/apis/meta/v1,Duration,Duration
 API rule violation: names_match,k8s.io/apimachinery/pkg/apis/meta/v1,InternalEvent,Object

cmd/controller-manager/app/controllers.go

@@ -35,12 +35,12 @@ import (
 
 	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
 
-	istioclientset "github.com/knative/pkg/client/clientset/versioned"
-	istioinformers "github.com/knative/pkg/client/informers/externalversions"
 	applicationclientset "github.com/kubernetes-sigs/application/pkg/client/clientset/versioned"
 	applicationinformers "github.com/kubernetes-sigs/application/pkg/client/informers/externalversions"
 	s2iclientset "github.com/kubesphere/s2ioperator/pkg/client/clientset/versioned"
 	s2iinformers "github.com/kubesphere/s2ioperator/pkg/client/informers/externalversions"
+	istioclientset "istio.io/client-go/pkg/clientset/versioned"
+	istioinformers "istio.io/client-go/pkg/informers/externalversions"
 	kubesphereclientset "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
 	kubesphereinformers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
 )

cmd/controller-manager/app/options/options.go

@@ -3,8 +3,7 @@ package options
 import (
 	"flag"
 	"github.com/spf13/pflag"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	apiserverconfig "k8s.io/apiserver/pkg/apis/config"
+	"k8s.io/client-go/tools/leaderelection"
 	cliflag "k8s.io/component-base/cli/flag"
 	"k8s.io/klog"
 	kubesphereconfig "kubesphere.io/kubesphere/pkg/server/config"
@@ -22,7 +21,7 @@ type KubeSphereControllerManagerOptions struct {
 	S3Options         *s2is3.S3Options
 	OpenPitrixOptions *openpitrix.OpenPitrixOptions
 
-	LeaderElection *apiserverconfig.LeaderElectionConfiguration
+	LeaderElection *leaderelection.LeaderElectionConfig
 }
 
 func NewKubeSphereControllerManagerOptions() *KubeSphereControllerManagerOptions {
@@ -31,12 +30,10 @@ func NewKubeSphereControllerManagerOptions() *KubeSphereControllerManagerOptions
 		DevopsOptions:     devops.NewDevopsOptions(),
 		S3Options:         s2is3.NewS3Options(),
 		OpenPitrixOptions: openpitrix.NewOpenPitrixOptions(),
-		LeaderElection: &apiserverconfig.LeaderElectionConfiguration{
-			LeaderElect:   false,
-			LeaseDuration: v1.Duration{Duration: 30 * time.Second},
-			RenewDeadline: v1.Duration{Duration: 15 * time.Second},
-			RetryPeriod:   v1.Duration{Duration: 5 * time.Second},
-			ResourceLock:  "ks-controller-manager-leader-election",
+		LeaderElection: &leaderelection.LeaderElectionConfig{
+			LeaseDuration: 30 * time.Second,
+			RenewDeadline: 15 * time.Second,
+			RetryPeriod:   5 * time.Second,
 		},
 	}
 
@@ -81,25 +78,18 @@ func (s *KubeSphereControllerManagerOptions) Validate() []error {
 	return errs
 }
 
-func (s *KubeSphereControllerManagerOptions) bindLeaderElectionFlags(l *apiserverconfig.LeaderElectionConfiguration, fs *pflag.FlagSet) {
-	fs.BoolVar(&l.LeaderElect, "leader-elect", l.LeaderElect, ""+
-		"Start a leader election client and gain leadership before "+
-		"executing the main loop. Enable this when running replicated "+
-		"components for high availability.")
-	fs.DurationVar(&l.LeaseDuration.Duration, "leader-elect-lease-duration", l.LeaseDuration.Duration, ""+
+func (s *KubeSphereControllerManagerOptions) bindLeaderElectionFlags(l *leaderelection.LeaderElectionConfig, fs *pflag.FlagSet) {
+	fs.DurationVar(&l.LeaseDuration, "leader-elect-lease-duration", l.LeaseDuration, ""+
 		"The duration that non-leader candidates will wait after observing a leadership "+
 		"renewal until attempting to acquire leadership of a led but unrenewed leader "+
 		"slot. This is effectively the maximum duration that a leader can be stopped "+
 		"before it is replaced by another candidate. This is only applicable if leader "+
 		"election is enabled.")
-	fs.DurationVar(&l.RenewDeadline.Duration, "leader-elect-renew-deadline", l.RenewDeadline.Duration, ""+
+	fs.DurationVar(&l.RenewDeadline, "leader-elect-renew-deadline", l.RenewDeadline, ""+
 		"The interval between attempts by the acting master to renew a leadership slot "+
 		"before it stops leading. This must be less than or equal to the lease duration. "+
 		"This is only applicable if leader election is enabled.")
-	fs.DurationVar(&l.RetryPeriod.Duration, "leader-elect-retry-period", l.RetryPeriod.Duration, ""+
+	fs.DurationVar(&l.RetryPeriod, "leader-elect-retry-period", l.RetryPeriod, ""+
 		"The duration the clients should wait between attempting acquisition and renewal "+
 		"of a leadership. This is only applicable if leader election is enabled.")
-	fs.StringVar(&l.ResourceLock, "leader-elect-resource-lock", l.ResourceLock, ""+
-		"The type of resource object that is used for locking during "+
-		"leader election. Supported options are `endpoints` (default) and `configmaps`.")
 }

cmd/controller-manager/app/server.go

@@ -157,10 +157,6 @@ func Run(s *options.KubeSphereControllerManagerOptions, stopCh <-chan struct{})
 		select {}
 	}
 
-	if !s.LeaderElection.LeaderElect {
-		run(context.TODO())
-	}
-
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
@@ -180,10 +176,11 @@ func Run(s *options.KubeSphereControllerManagerOptions, stopCh <-chan struct{})
 	// TODO: change lockType to lease
 	// once we finished moving to Kubernetes v1.16+, we
 	// change lockType to lease
-	lock, err := resourcelock.New("endpoints",
+	lock, err := resourcelock.New(resourcelock.LeasesResourceLock,
 		"kubesphere-system",
-		s.LeaderElection.ResourceLock,
+		"ks-controller-manager",
 		client.ClientSets().K8s().Kubernetes().CoreV1(),
+		client.ClientSets().K8s().Kubernetes().CoordinationV1(),
 		resourcelock.ResourceLockConfig{
 			Identity: id,
 			EventRecorder: record.NewBroadcaster().NewRecorder(scheme.Scheme, v1.EventSource{
@@ -197,9 +194,9 @@ func Run(s *options.KubeSphereControllerManagerOptions, stopCh <-chan struct{})
 
 	leaderelection.RunOrDie(ctx, leaderelection.LeaderElectionConfig{
 		Lock:          lock,
-		LeaseDuration: s.LeaderElection.LeaseDuration.Duration,
-		RenewDeadline: s.LeaderElection.RenewDeadline.Duration,
-		RetryPeriod:   s.LeaderElection.RetryPeriod.Duration,
+		LeaseDuration: s.LeaderElection.LeaseDuration,
+		RenewDeadline: s.LeaderElection.RenewDeadline,
+		RetryPeriod:   s.LeaderElection.RetryPeriod,
 		Callbacks: leaderelection.LeaderCallbacks{
 			OnStartedLeading: run,
 			OnStoppedLeading: func() {

hack/generate_group.sh

@@ -50,7 +50,6 @@ shift 4
 
 GO111MODULE=on go install -mod=vendor k8s.io/code-generator/cmd/{client-gen,lister-gen,informer-gen}
 
-
 function codegen::join() { local IFS="$1"; shift; echo "$*"; }
 
 # enumerate group versions

pkg/apis/addtoscheme_servicemesh_v1alpha2.go

@@ -17,7 +17,7 @@ limitations under the License.
 package apis
 
 import (
-	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"istio.io/client-go/pkg/apis/networking/v1alpha3"
 	"kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
 
 	"github.com/kubernetes-sigs/application/pkg/apis/app/v1beta1"

pkg/apis/servicemesh/v1alpha2/servicepolicy_types.go

@@ -17,7 +17,7 @@ limitations under the License.
 package v1alpha2
 
 import (
-	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"istio.io/api/networking/v1alpha3"
 	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -51,7 +51,7 @@ type DestinationRuleSpecTemplate struct {
 
 	// Spec indicates the behavior of a destination rule.
 	// +optional
-	Spec v1alpha3.DestinationRuleSpec `json:"spec,omitempty"`
+	Spec v1alpha3.DestinationRule `json:"spec,omitempty"`
 }
 
 type ServicePolicyConditionType string

pkg/apis/servicemesh/v1alpha2/servicepolicy_types_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package v1alpha2
 
 import (
+	"istio.io/api/networking/v1alpha3"
 	"testing"
 
 	"github.com/onsi/gomega"
@@ -34,7 +35,15 @@ func TestStorageServicePolicy(t *testing.T) {
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "foo",
 			Namespace: "default",
-		}}
+		},
+		Spec: ServicePolicySpec{
+			Template: DestinationRuleSpecTemplate{
+				Spec: v1alpha3.DestinationRule{
+					Host: "foo",
+				},
+			},
+		},
+	}
 	g := gomega.NewGomegaWithT(t)
 
 	// Test Create

pkg/apis/servicemesh/v1alpha2/strategy_types.go

@@ -17,7 +17,7 @@ limitations under the License.
 package v1alpha2
 
 import (
-	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"istio.io/api/networking/v1alpha3"
 	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
@@ -93,7 +93,7 @@ type VirtualServiceTemplateSpec struct {
 
 	// Spec indicates the behavior of a virtual service.
 	// +optional
-	Spec v1alpha3.VirtualServiceSpec `json:"spec,omitempty"`
+	Spec v1alpha3.VirtualService `json:"spec,omitempty"`
 }
 
 // StrategyStatus defines the observed state of Strategy

pkg/apis/servicemesh/v1alpha2/strategy_types_test.go

@@ -17,8 +17,8 @@ limitations under the License.
 package v1alpha2
 
 import (
-	"github.com/knative/pkg/apis/istio/v1alpha3"
 	"io/ioutil"
+	apinetworkingv1alpha3 "istio.io/api/networking/v1alpha3"
 	"k8s.io/apimachinery/pkg/util/json"
 	"k8s.io/client-go/kubernetes/scheme"
 	"testing"
@@ -41,7 +41,7 @@ func TestStorageStrategy(t *testing.T) {
 		},
 		Spec: StrategySpec{
 			Template: VirtualServiceTemplateSpec{
-				Spec: v1alpha3.VirtualServiceSpec{
+				Spec: apinetworkingv1alpha3.VirtualService{
 					Hosts: []string{
 						"details",
 					},

pkg/client/clientset/versioned/clientset.go

@@ -19,6 +19,8 @@ limitations under the License.
 package versioned
 
 import (
+	"fmt"
+
 	discovery "k8s.io/client-go/discovery"
 	rest "k8s.io/client-go/rest"
 	flowcontrol "k8s.io/client-go/util/flowcontrol"
@@ -31,17 +33,9 @@ import (
 type Interface interface {
 	Discovery() discovery.DiscoveryInterface
 	DevopsV1alpha1() devopsv1alpha1.DevopsV1alpha1Interface
-	// Deprecated: please explicitly pick a version if possible.
-	Devops() devopsv1alpha1.DevopsV1alpha1Interface
 	NetworkV1alpha1() networkv1alpha1.NetworkV1alpha1Interface
-	// Deprecated: please explicitly pick a version if possible.
-	Network() networkv1alpha1.NetworkV1alpha1Interface
 	ServicemeshV1alpha2() servicemeshv1alpha2.ServicemeshV1alpha2Interface
-	// Deprecated: please explicitly pick a version if possible.
-	Servicemesh() servicemeshv1alpha2.ServicemeshV1alpha2Interface
 	TenantV1alpha1() tenantv1alpha1.TenantV1alpha1Interface
-	// Deprecated: please explicitly pick a version if possible.
-	Tenant() tenantv1alpha1.TenantV1alpha1Interface
 }
 
 // Clientset contains the clients for groups. Each group has exactly one
@@ -59,45 +53,21 @@ func (c *Clientset) DevopsV1alpha1() devopsv1alpha1.DevopsV1alpha1Interface {
 	return c.devopsV1alpha1
 }
 
-// Deprecated: Devops retrieves the default version of DevopsClient.
-// Please explicitly pick a version.
-func (c *Clientset) Devops() devopsv1alpha1.DevopsV1alpha1Interface {
-	return c.devopsV1alpha1
-}
-
 // NetworkV1alpha1 retrieves the NetworkV1alpha1Client
 func (c *Clientset) NetworkV1alpha1() networkv1alpha1.NetworkV1alpha1Interface {
 	return c.networkV1alpha1
 }
 
-// Deprecated: Network retrieves the default version of NetworkClient.
-// Please explicitly pick a version.
-func (c *Clientset) Network() networkv1alpha1.NetworkV1alpha1Interface {
-	return c.networkV1alpha1
-}
-
 // ServicemeshV1alpha2 retrieves the ServicemeshV1alpha2Client
 func (c *Clientset) ServicemeshV1alpha2() servicemeshv1alpha2.ServicemeshV1alpha2Interface {
 	return c.servicemeshV1alpha2
 }
 
-// Deprecated: Servicemesh retrieves the default version of ServicemeshClient.
-// Please explicitly pick a version.
-func (c *Clientset) Servicemesh() servicemeshv1alpha2.ServicemeshV1alpha2Interface {
-	return c.servicemeshV1alpha2
-}
-
 // TenantV1alpha1 retrieves the TenantV1alpha1Client
 func (c *Clientset) TenantV1alpha1() tenantv1alpha1.TenantV1alpha1Interface {
 	return c.tenantV1alpha1
 }
 
-// Deprecated: Tenant retrieves the default version of TenantClient.
-// Please explicitly pick a version.
-func (c *Clientset) Tenant() tenantv1alpha1.TenantV1alpha1Interface {
-	return c.tenantV1alpha1
-}
-
 // Discovery retrieves the DiscoveryClient
 func (c *Clientset) Discovery() discovery.DiscoveryInterface {
 	if c == nil {
@@ -107,9 +77,14 @@ func (c *Clientset) Discovery() discovery.DiscoveryInterface {
 }
 
 // NewForConfig creates a new Clientset for the given config.
+// If config's RateLimiter is not set and QPS and Burst are acceptable,
+// NewForConfig will generate a rate-limiter in configShallowCopy.
 func NewForConfig(c *rest.Config) (*Clientset, error) {
 	configShallowCopy := *c
 	if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
+		if configShallowCopy.Burst <= 0 {
+			return nil, fmt.Errorf("Burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0")
+		}
 		configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
 	}
 	var cs Clientset

pkg/client/clientset/versioned/fake/clientset_generated.go

@@ -47,7 +47,7 @@ func NewSimpleClientset(objects ...runtime.Object) *Clientset {
 		}
 	}
 
-	cs := &Clientset{}
+	cs := &Clientset{tracker: o}
 	cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake}
 	cs.AddReactor("*", "*", testing.ObjectReaction(o))
 	cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {
@@ -69,12 +69,17 @@ func NewSimpleClientset(objects ...runtime.Object) *Clientset {
 type Clientset struct {
 	testing.Fake
 	discovery *fakediscovery.FakeDiscovery
+	tracker   testing.ObjectTracker
 }
 
 func (c *Clientset) Discovery() discovery.DiscoveryInterface {
 	return c.discovery
 }
 
+func (c *Clientset) Tracker() testing.ObjectTracker {
+	return c.tracker
+}
+
 var _ clientset.Interface = &Clientset{}
 
 // DevopsV1alpha1 retrieves the DevopsV1alpha1Client
@@ -82,37 +87,17 @@ func (c *Clientset) DevopsV1alpha1() devopsv1alpha1.DevopsV1alpha1Interface {
 	return &fakedevopsv1alpha1.FakeDevopsV1alpha1{Fake: &c.Fake}
 }
 
-// Devops retrieves the DevopsV1alpha1Client
-func (c *Clientset) Devops() devopsv1alpha1.DevopsV1alpha1Interface {
-	return &fakedevopsv1alpha1.FakeDevopsV1alpha1{Fake: &c.Fake}
-}
-
 // NetworkV1alpha1 retrieves the NetworkV1alpha1Client
 func (c *Clientset) NetworkV1alpha1() networkv1alpha1.NetworkV1alpha1Interface {
 	return &fakenetworkv1alpha1.FakeNetworkV1alpha1{Fake: &c.Fake}
 }
 
-// Network retrieves the NetworkV1alpha1Client
-func (c *Clientset) Network() networkv1alpha1.NetworkV1alpha1Interface {
-	return &fakenetworkv1alpha1.FakeNetworkV1alpha1{Fake: &c.Fake}
-}
-
 // ServicemeshV1alpha2 retrieves the ServicemeshV1alpha2Client
 func (c *Clientset) ServicemeshV1alpha2() servicemeshv1alpha2.ServicemeshV1alpha2Interface {
 	return &fakeservicemeshv1alpha2.FakeServicemeshV1alpha2{Fake: &c.Fake}
 }
 
-// Servicemesh retrieves the ServicemeshV1alpha2Client
-func (c *Clientset) Servicemesh() servicemeshv1alpha2.ServicemeshV1alpha2Interface {
-	return &fakeservicemeshv1alpha2.FakeServicemeshV1alpha2{Fake: &c.Fake}
-}
-
 // TenantV1alpha1 retrieves the TenantV1alpha1Client
 func (c *Clientset) TenantV1alpha1() tenantv1alpha1.TenantV1alpha1Interface {
 	return &faketenantv1alpha1.FakeTenantV1alpha1{Fake: &c.Fake}
 }
-
-// Tenant retrieves the TenantV1alpha1Client
-func (c *Clientset) Tenant() tenantv1alpha1.TenantV1alpha1Interface {
-	return &faketenantv1alpha1.FakeTenantV1alpha1{Fake: &c.Fake}
-}

pkg/client/clientset/versioned/typed/devops/v1alpha1/devops_client.go

@@ -19,7 +19,6 @@ limitations under the License.
 package v1alpha1
 
 import (
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	rest "k8s.io/client-go/rest"
 	v1alpha1 "kubesphere.io/kubesphere/pkg/apis/devops/v1alpha1"
 	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/scheme"
@@ -71,7 +70,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
+	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
 
 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()

pkg/client/clientset/versioned/typed/network/v1alpha1/network_client.go

@@ -19,7 +19,6 @@ limitations under the License.
 package v1alpha1
 
 import (
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	rest "k8s.io/client-go/rest"
 	v1alpha1 "kubesphere.io/kubesphere/pkg/apis/network/v1alpha1"
 	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/scheme"
@@ -76,7 +75,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
+	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
 
 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()

pkg/client/clientset/versioned/typed/servicemesh/v1alpha2/servicemesh_client.go

@@ -19,7 +19,6 @@ limitations under the License.
 package v1alpha2
 
 import (
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	rest "k8s.io/client-go/rest"
 	v1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
 	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/scheme"
@@ -76,7 +75,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha2.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
+	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
 
 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()

pkg/client/clientset/versioned/typed/tenant/v1alpha1/tenant_client.go

@@ -19,7 +19,6 @@ limitations under the License.
 package v1alpha1
 
 import (
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	rest "k8s.io/client-go/rest"
 	v1alpha1 "kubesphere.io/kubesphere/pkg/apis/tenant/v1alpha1"
 	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/scheme"
@@ -71,7 +70,7 @@ func setConfigDefaults(config *rest.Config) error {
 	gv := v1alpha1.SchemeGroupVersion
 	config.GroupVersion = &gv
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
+	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
 
 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()

pkg/controller/add_strategy.go

@@ -17,7 +17,7 @@ limitations under the License.
 package controller
 
 import (
-	"sigs.k8s.io/application/pkg/controller/application"
+	"github.com/kubernetes-sigs/application/pkg/controller/application"
 )
 
 func init() {

pkg/controller/clusterrolebinding/clusterrolebinding_controller.go

@@ -104,7 +104,7 @@ func (r *ReconcileClusterRoleBinding) Reconcile(request reconcile.Request) (reco
 			nsList := &corev1.NamespaceList{}
 			options := client.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set{constants.WorkspaceLabelKey: workspaceName})}
 
-			if err := r.List(context.TODO(), &options, nsList); err != nil {
+			if err := r.List(context.TODO(), nsList, &options); err != nil {
 				return reconcile.Result{}, err
 			}
 			for _, ns := range nsList.Items {

pkg/controller/destinationrule/destinationrule_controller.go

@@ -4,7 +4,8 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/knative/pkg/apis/istio/v1alpha3"
+	apinetworkingv1alpha3 "istio.io/api/networking/v1alpha3"
+	clientgonetworkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
 	appsv1 "k8s.io/api/apps/v1"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -22,9 +23,9 @@ import (
 
 	"time"
 
-	istioclientset "github.com/knative/pkg/client/clientset/versioned"
-	istioinformers "github.com/knative/pkg/client/informers/externalversions/istio/v1alpha3"
-	istiolisters "github.com/knative/pkg/client/listers/istio/v1alpha3"
+	istioclientset "istio.io/client-go/pkg/clientset/versioned"
+	istioinformers "istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3"
+	istiolisters "istio.io/client-go/pkg/listers/networking/v1alpha3"
 	informersv1 "k8s.io/client-go/informers/apps/v1"
 	coreinformers "k8s.io/client-go/informers/core/v1"
 	clientset "k8s.io/client-go/kubernetes"
@@ -244,7 +245,7 @@ func (v *DestinationRuleController) syncService(key string) error {
 		return err
 	}
 
-	subsets := make([]v1alpha3.Subset, 0)
+	subsets := make([]*apinetworkingv1alpha3.Subset, 0)
 	for _, deployment := range deployments {
 
 		// not a valid deployment we required
@@ -262,7 +263,7 @@ func (v *DestinationRuleController) syncService(key string) error {
 			continue
 		}
 
-		subset := v1alpha3.Subset{
+		subset := &apinetworkingv1alpha3.Subset{
 			Name: util.NormalizeVersionName(version),
 			Labels: map[string]string{
 				util.VersionLabel: version,
@@ -275,12 +276,12 @@ func (v *DestinationRuleController) syncService(key string) error {
 	currentDestinationRule, err := v.destinationRuleLister.DestinationRules(namespace).Get(name)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			currentDestinationRule = &v1alpha3.DestinationRule{
+			currentDestinationRule = &clientgonetworkingv1alpha3.DestinationRule{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:   service.Name,
 					Labels: service.Labels,
 				},
-				Spec: v1alpha3.DestinationRuleSpec{
+				Spec: apinetworkingv1alpha3.DestinationRule{
 					Host: name,
 				},
 			}

pkg/controller/destinationrule/destinationrule_controller_test.go

 package destinationrule
 
 import (
+	"fmt"
+	apiv1alpha3 "istio.io/api/networking/v1alpha3"
+	"istio.io/client-go/pkg/apis/networking/v1alpha3"
+	istiofake "istio.io/client-go/pkg/clientset/versioned/fake"
+	istioinformers "istio.io/client-go/pkg/informers/externalversions"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	kubeinformers "k8s.io/client-go/informers"
+	kubefake "k8s.io/client-go/kubernetes/fake"
+	"k8s.io/client-go/tools/cache"
+	"k8s.io/client-go/tools/record"
+	"kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/client/clientset/versioned/fake"
+	informers "kubesphere.io/kubesphere/pkg/client/informers/externalversions"
+	"kubesphere.io/kubesphere/pkg/controller/virtualservice/util"
+	"kubesphere.io/kubesphere/pkg/utils/reflectutils"
+	"testing"
 )
 
-// TODO(jeff): add test cases
-
-var namespace = "default"
-var lbs = map[string]string{
-	"app.kubernetes.io/name":            "bookinfo",
-	"servicemesh.kubesphere.io/enabled": "",
-	"app":                               "reviews",
-}
+var (
+	alwaysReady = func() bool { return true }
+	replicas    = int32(2)
+)
 
-var service = corev1.Service{}
+func newDeployments(service *corev1.Service, version string) *appsv1.Deployment {
+	lbs := service.Labels
+	lbs["version"] = version
 
-var deployments = []appsv1.Deployment{
-	{
+	deployment := &appsv1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
-			Namespace: namespace,
-			Name:      "deploy-v1",
-			Labels: map[string]string{
-				"app.kubernetes.io/name":            "bookinfo",
-				"servicemesh.kubesphere.io/enabled": "",
-				"app":                               "reviews",
-				"version":                           "v1",
-			},
+			Name:        fmt.Sprintf("%s-%s", service.Name, version),
+			Namespace:   metav1.NamespaceDefault,
+			Labels:      lbs,
+			Annotations: service.Annotations,
 		},
 		Spec: appsv1.DeploymentSpec{
+			Replicas: &replicas,
 			Selector: &metav1.LabelSelector{
-				MatchLabels: map[string]string{
-					"app.kubernetes.io/name":            "bookinfo",
-					"servicemesh.kubesphere.io/enabled": "",
-					"app":                               "reviews",
-					"version":                           "v1",
-				},
+				MatchLabels: lbs,
 			},
 			Template: corev1.PodTemplateSpec{
 				ObjectMeta: metav1.ObjectMeta{
-					Labels: map[string]string{
-						"app.kubernetes.io/name":            "bookinfo",
-						"servicemesh.kubesphere.io/enabled": "",
-						"app":                               "reviews",
-						"version":                           "v1",
-					},
+					Labels:      lbs,
+					Annotations: service.Annotations,
 				},
 				Spec: corev1.PodSpec{
 					Containers: []corev1.Container{
-						{},
+						{
+							Name:  "c1",
+							Image: "nginx:latest",
+							Ports: []corev1.ContainerPort{
+								{
+									Name:          "http",
+									ContainerPort: 80,
+									Protocol:      corev1.ProtocolTCP,
+								},
+								{
+									Name:          "https",
+									ContainerPort: 443,
+									Protocol:      corev1.ProtocolTCP,
+								},
+								{
+									Name:          "mysql",
+									ContainerPort: 3306,
+									Protocol:      corev1.ProtocolTCP,
+								},
+							},
+						},
 					},
 				},
 			},
 		},
-	},
+		Status: appsv1.DeploymentStatus{
+			AvailableReplicas: replicas,
+			ReadyReplicas:     replicas,
+			Replicas:          replicas,
+		},
+	}
+
+	return deployment
+}
+
+func newDestinationRule(service *corev1.Service, deployments ...*appsv1.Deployment) *v1alpha3.DestinationRule {
+	dr := &v1alpha3.DestinationRule{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:        service.Name,
+			Namespace:   service.Namespace,
+			Labels:      service.Labels,
+			Annotations: make(map[string]string),
+		},
+		Spec: apiv1alpha3.DestinationRule{
+			Host: service.Name,
+		},
+	}
+
+	dr.Spec.Subsets = []*apiv1alpha3.Subset{}
+	for _, deployment := range deployments {
+		subset := &apiv1alpha3.Subset{
+			Name: util.GetComponentVersion(&deployment.ObjectMeta),
+			Labels: map[string]string{
+				"version": util.GetComponentVersion(&deployment.ObjectMeta),
+			},
+		}
+		dr.Spec.Subsets = append(dr.Spec.Subsets, subset)
+	}
+
+	return dr
+}
+
+func newService(name string) *corev1.Service {
+	service := &corev1.Service{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo",
+			Namespace: metav1.NamespaceDefault,
+			Labels: map[string]string{
+				"app.kubernetes.io/name":    "bookinfo",
+				"app.kubernetes.io/version": "1",
+				"app":                       "foo",
+			},
+			Annotations: map[string]string{
+				"servicemesh.kubesphere.io/enabled": "true",
+			},
+		},
+		Spec: corev1.ServiceSpec{
+			Ports: []corev1.ServicePort{
+				{
+					Name:     "http",
+					Port:     80,
+					Protocol: corev1.ProtocolTCP,
+				},
+				{
+					Name:     "https",
+					Port:     443,
+					Protocol: corev1.ProtocolTCP,
+				},
+				{
+					Name:     "mysql",
+					Port:     3306,
+					Protocol: corev1.ProtocolTCP,
+				},
+			},
+			Selector: map[string]string{
+				"app.kubernetes.io/name":    "bookinfo",
+				"app.kubernetes.io/version": "1",
+				"app":                       "foo",
+			},
+			Type: corev1.ServiceTypeClusterIP,
+		},
+		Status: corev1.ServiceStatus{},
+	}
+
+	return service
+
+}
+
+func newServicePolicy(name string, service *corev1.Service, deployments ...*appsv1.Deployment) *v1alpha2.ServicePolicy {
+	sp := &v1alpha2.ServicePolicy{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:        name,
+			Namespace:   metav1.NamespaceDefault,
+			Labels:      service.Labels,
+			Annotations: service.Annotations,
+		},
+		Spec: v1alpha2.ServicePolicySpec{
+			Template: v1alpha2.DestinationRuleSpecTemplate{
+				Spec: apiv1alpha3.DestinationRule{
+					Host: service.Name,
+				},
+			},
+		},
+	}
+
+	sp.Spec.Template.Spec.Subsets = []*apiv1alpha3.Subset{}
+	for _, deployment := range deployments {
+		subset := &apiv1alpha3.Subset{
+			Name: util.GetComponentVersion(&deployment.ObjectMeta),
+			Labels: map[string]string{
+				"version": util.GetComponentVersion(&deployment.ObjectMeta),
+			},
+		}
+		sp.Spec.Template.Spec.Subsets = append(sp.Spec.Template.Spec.Subsets, subset)
+	}
+
+	return sp
+}
+
+type fixture struct {
+	t testing.TB
+
+	kubeClient        *kubefake.Clientset
+	istioClient       *istiofake.Clientset
+	servicemeshClient *fake.Clientset
+
+	serviceLister    []*corev1.Service
+	deploymentLister []*appsv1.Deployment
+	drLister         []*v1alpha3.DestinationRule
+	spLister         []*v1alpha2.ServicePolicy
+
+	kubeObjects        []runtime.Object
+	istioObjects       []runtime.Object
+	servicemeshObjects []runtime.Object
+}
+
+func newFixture(t testing.TB) *fixture {
+	f := &fixture{}
+	f.t = t
+	f.kubeObjects = []runtime.Object{}
+	f.istioObjects = []runtime.Object{}
+	f.servicemeshObjects = []runtime.Object{}
+	return f
+}
+
+func (f *fixture) newController() (*DestinationRuleController, kubeinformers.SharedInformerFactory, istioinformers.SharedInformerFactory, informers.SharedInformerFactory, error) {
+	f.kubeClient = kubefake.NewSimpleClientset(f.kubeObjects...)
+	f.servicemeshClient = fake.NewSimpleClientset(f.servicemeshObjects...)
+	f.istioClient = istiofake.NewSimpleClientset(f.istioObjects...)
+	kubeInformers := kubeinformers.NewSharedInformerFactory(f.kubeClient, 0)
+	istioInformers := istioinformers.NewSharedInformerFactory(f.istioClient, 0)
+	servicemeshInformers := informers.NewSharedInformerFactory(f.servicemeshClient, 0)
+
+	c := NewDestinationRuleController(kubeInformers.Apps().V1().Deployments(),
+		istioInformers.Networking().V1alpha3().DestinationRules(),
+		kubeInformers.Core().V1().Services(),
+		servicemeshInformers.Servicemesh().V1alpha2().ServicePolicies(),
+		f.kubeClient,
+		f.istioClient,
+		f.servicemeshClient)
+	c.eventRecorder = &record.FakeRecorder{}
+	c.destinationRuleSynced = alwaysReady
+	c.deploymentSynced = alwaysReady
+	c.servicePolicySynced = alwaysReady
+	c.serviceSynced = alwaysReady
+
+	for _, s := range f.serviceLister {
+		kubeInformers.Core().V1().Services().Informer().GetIndexer().Add(s)
+	}
+
+	for _, d := range f.drLister {
+		istioInformers.Networking().V1alpha3().DestinationRules().Informer().GetIndexer().Add(d)
+	}
+
+	for _, d := range f.deploymentLister {
+		kubeInformers.Apps().V1().Deployments().Informer().GetIndexer().Add(d)
+	}
+
+	for _, s := range f.spLister {
+		servicemeshInformers.Servicemesh().V1alpha2().ServicePolicies().Informer().GetIndexer().Add(s)
+	}
+
+	return c, kubeInformers, istioInformers, servicemeshInformers, nil
+}
+
+func (f *fixture) run(service *corev1.Service, expected *v1alpha3.DestinationRule, startInformers bool, expectedError bool) {
+	c, kubeInformers, istioInformers, servicemeshInformers, err := f.newController()
+	if err != nil {
+		f.t.Fatal(err)
+	}
+
+	if startInformers {
+		stopCh := make(chan struct{})
+		defer close(stopCh)
+		kubeInformers.Start(stopCh)
+		istioInformers.Start(stopCh)
+		servicemeshInformers.Start(stopCh)
+	}
+
+	key, err := cache.MetaNamespaceKeyFunc(service)
+	if err != nil {
+		f.t.Fatal(err)
+	}
+
+	err = c.syncService(key)
+	if !expectedError && err != nil {
+		f.t.Fatalf("error syncing service: %v", err)
+	} else if expectedError && err == nil {
+		f.t.Fatal("expected error syncing service, got nil")
+	}
+
+	got, err := c.destinationRuleClient.NetworkingV1alpha3().DestinationRules(service.Namespace).Get(service.Name, metav1.GetOptions{})
+	if err != nil {
+		f.t.Fatal(err)
+	}
+
+	if unequals := reflectutils.Equal(got, expected); len(unequals) != 0 {
+		f.t.Errorf("expected %#v, got %#v, unequal fields:", expected, got)
+		for _, unequal := range unequals {
+			f.t.Error(unequal)
+		}
+	}
+
+}
+
+func runServicePolicy(t *testing.T, service *corev1.Service, sp *v1alpha2.ServicePolicy, expected *v1alpha3.DestinationRule, expectedError bool, deployments ...*appsv1.Deployment) {
+	f := newFixture(t)
+
+	f.kubeObjects = append(f.kubeObjects, service)
+	f.serviceLister = append(f.serviceLister, service)
+	for _, deployment := range deployments {
+		f.kubeObjects = append(f.kubeObjects, deployment)
+		f.deploymentLister = append(f.deploymentLister, deployment)
+	}
+	if sp != nil {
+		f.servicemeshObjects = append(f.servicemeshObjects, sp)
+		f.spLister = append(f.spLister, sp)
+	}
+
+	f.run(service, expected, true, expectedError)
+}
+
+func TestServicePolicy(t *testing.T) {
+	defaultService := newService("foo")
+	defaultDeploymentV1 := newDeployments(defaultService, "v1")
+	defaultDeploymentV2 := newDeployments(defaultService, "v2")
+	defaultServicePolicy := newServicePolicy("foo", defaultService, defaultDeploymentV1, defaultDeploymentV2)
+	defaultExpected := newDestinationRule(defaultService, defaultDeploymentV1, defaultDeploymentV2)
+
+	t.Run("should create default destination rule", func(t *testing.T) {
+		runServicePolicy(t, defaultService, nil, defaultExpected, false, defaultDeploymentV1, defaultDeploymentV2)
+	})
+
+	t.Run("should create destination rule only to v1", func(t *testing.T) {
+		deploymentV2 := defaultDeploymentV2.DeepCopy()
+		deploymentV2.Status.AvailableReplicas = 0
+		deploymentV2.Status.ReadyReplicas = 0
+
+		expected := defaultExpected.DeepCopy()
+		expected.Spec.Subsets = expected.Spec.Subsets[:1]
+		runServicePolicy(t, defaultService, nil, expected, false, defaultDeploymentV1, deploymentV2)
+	})
+
+	t.Run("should create destination rule match service policy", func(t *testing.T) {
+		sp := defaultServicePolicy.DeepCopy()
+		sp.Spec.Template.Spec.TrafficPolicy = &apiv1alpha3.TrafficPolicy{
+			LoadBalancer: &apiv1alpha3.LoadBalancerSettings{
+				LbPolicy: &apiv1alpha3.LoadBalancerSettings_Simple{
+					Simple: apiv1alpha3.LoadBalancerSettings_ROUND_ROBIN,
+				},
+			},
+			ConnectionPool: &apiv1alpha3.ConnectionPoolSettings{
+				Http: &apiv1alpha3.ConnectionPoolSettings_HTTPSettings{
+					Http1MaxPendingRequests:  10,
+					Http2MaxRequests:         20,
+					MaxRequestsPerConnection: 5,
+					MaxRetries:               4,
+				},
+			},
+			OutlierDetection: &apiv1alpha3.OutlierDetection{
+				ConsecutiveErrors:  5,
+				MaxEjectionPercent: 10,
+				MinHealthPercent:   20,
+			},
+		}
+
+		expected := defaultExpected.DeepCopy()
+		expected.Spec.TrafficPolicy = sp.Spec.Template.Spec.TrafficPolicy
+		runServicePolicy(t, defaultService, sp, expected, false, defaultDeploymentV1, defaultDeploymentV2)
+	})
 }

pkg/controller/virtualservice/util/util.go

 package util
 
 import (
-	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"istio.io/api/networking/v1alpha3"
+	clientgonetworkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"strings"
@@ -90,17 +91,22 @@ func IsApplicationComponent(lbs map[string]string) bool {
 }
 
 // if virtualservice not specified with port number, then fill with service first port
-func FillDestinationPort(vs *v1alpha3.VirtualService, service *v1.Service) {
+func FillDestinationPort(vs *clientgonetworkingv1alpha3.VirtualService, service *v1.Service) {
 	// fill http port
 	for i := range vs.Spec.Http {
 		for j := range vs.Spec.Http[i].Route {
-			if vs.Spec.Http[i].Route[j].Destination.Port.Number == 0 {
-				vs.Spec.Http[i].Route[j].Destination.Port.Number = uint32(service.Spec.Ports[0].Port)
+			port := vs.Spec.Http[i].Route[j].Destination.Port
+			if port == nil || port.Number == 0 {
+				vs.Spec.Http[i].Route[j].Destination.Port = &v1alpha3.PortSelector{
+					Number: uint32(service.Spec.Ports[0].Port),
+				}
 			}
 		}
 
-		if vs.Spec.Http[i].Mirror != nil && vs.Spec.Http[i].Mirror.Port.Number == 0 {
-			vs.Spec.Http[i].Mirror.Port.Number = uint32(service.Spec.Ports[0].Port)
+		if vs.Spec.Http[i].Mirror != nil && (vs.Spec.Http[i].Mirror.Port == nil || vs.Spec.Http[i].Mirror.Port.Number == 0) {
+			vs.Spec.Http[i].Mirror.Port = &v1alpha3.PortSelector{
+				Number: uint32(service.Spec.Ports[0].Port),
+			}
 		}
 	}
 
@@ -108,7 +114,9 @@ func FillDestinationPort(vs *v1alpha3.VirtualService, service *v1.Service) {
 	for i := range vs.Spec.Tcp {
 		for j := range vs.Spec.Tcp[i].Route {
 			if vs.Spec.Tcp[i].Route[j].Destination.Port.Number == 0 {
-				vs.Spec.Tcp[i].Route[j].Destination.Port.Number = uint32(service.Spec.Ports[0].Port)
+				vs.Spec.Tcp[i].Route[j].Destination.Port = &v1alpha3.PortSelector{
+					Number: uint32(service.Spec.Ports[0].Port),
+				}
 			}
 		}
 	}

pkg/controller/virtualservice/virtualservice_controller.go

@@ -5,7 +5,8 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/knative/pkg/apis/istio/v1alpha3"
+	apinetworkingv1alpha3 "istio.io/api/networking/v1alpha3"
+	clientgonetworkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -19,9 +20,9 @@ import (
 	log "k8s.io/klog"
 	"kubesphere.io/kubesphere/pkg/controller/virtualservice/util"
 
-	istioclient "github.com/knative/pkg/client/clientset/versioned"
-	istioinformers "github.com/knative/pkg/client/informers/externalversions/istio/v1alpha3"
-	istiolisters "github.com/knative/pkg/client/listers/istio/v1alpha3"
+	istioclient "istio.io/client-go/pkg/clientset/versioned"
+	istioinformers "istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3"
+	istiolisters "istio.io/client-go/pkg/listers/networking/v1alpha3"
 	coreinformers "k8s.io/client-go/informers/core/v1"
 	clientset "k8s.io/client-go/kubernetes"
 	corelisters "k8s.io/client-go/listers/core/v1"
@@ -284,7 +285,7 @@ func (v *VirtualServiceController) syncService(key string) error {
 	currentVirtualService, err := v.virtualServiceLister.VirtualServices(namespace).Get(appName)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			currentVirtualService = &v1alpha3.VirtualService{
+			currentVirtualService = &clientgonetworkingv1alpha3.VirtualService{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      appName,
 					Namespace: namespace,
@@ -305,13 +306,13 @@ func (v *VirtualServiceController) syncService(key string) error {
 
 	// check if service has TCP protocol ports
 	for _, port := range service.Spec.Ports {
-		var route v1alpha3.DestinationWeight
+		var route apinetworkingv1alpha3.HTTPRouteDestination
 		if port.Protocol == v1.ProtocolTCP {
-			route = v1alpha3.DestinationWeight{
-				Destination: v1alpha3.Destination{
+			route = apinetworkingv1alpha3.HTTPRouteDestination{
+				Destination: &apinetworkingv1alpha3.Destination{
 					Host:   name,
 					Subset: subsets[0].Name,
-					Port: v1alpha3.PortSelector{
+					Port: &apinetworkingv1alpha3.PortSelector{
 						Number: uint32(port.Port),
 					},
 				},
@@ -320,12 +321,20 @@ func (v *VirtualServiceController) syncService(key string) error {
 
 			// a http port, add to HTTPRoute
 			if len(port.Name) > 0 && (port.Name == "http" || strings.HasPrefix(port.Name, "http-")) {
-				vs.Spec.Http = []v1alpha3.HTTPRoute{{Route: []v1alpha3.DestinationWeight{route}}}
+				vs.Spec.Http = []*apinetworkingv1alpha3.HTTPRoute{{Route: []*apinetworkingv1alpha3.HTTPRouteDestination{&route}}}
 				break
 			}
 
 			// everything else treated as TCPRoute
-			vs.Spec.Tcp = []v1alpha3.TCPRoute{{Route: []v1alpha3.DestinationWeight{route}}}
+			tcpRoute := apinetworkingv1alpha3.TCPRoute{
+				Route: []*apinetworkingv1alpha3.RouteDestination{
+					{
+						Destination: route.Destination,
+						Weight:      route.Weight,
+					},
+				},
+			}
+			vs.Spec.Tcp = []*apinetworkingv1alpha3.TCPRoute{&tcpRoute}
 		}
 	}
 
@@ -407,7 +416,7 @@ func (v *VirtualServiceController) syncService(key string) error {
 // When a destinationrule is added, figure out which service it will be used
 // and enqueue it. obj must have *v1alpha3.DestinationRule type
 func (v *VirtualServiceController) addDestinationRule(obj interface{}) {
-	dr := obj.(*v1alpha3.DestinationRule)
+	dr := obj.(*clientgonetworkingv1alpha3.DestinationRule)
 	service, err := v.serviceLister.Services(dr.Namespace).Get(dr.Name)
 	if err != nil {
 		if errors.IsNotFound(err) {
@@ -523,17 +532,17 @@ func (v *VirtualServiceController) getSubsets(strategy *servicemeshv1alpha2.Stra
 	return set
 }
 
-func (v *VirtualServiceController) generateVirtualServiceSpec(strategy *servicemeshv1alpha2.Strategy, service *v1.Service) *v1alpha3.VirtualService {
+func (v *VirtualServiceController) generateVirtualServiceSpec(strategy *servicemeshv1alpha2.Strategy, service *v1.Service) *clientgonetworkingv1alpha3.VirtualService {
 
 	// Define VirtualService to be created
-	vs := &v1alpha3.VirtualService{
+	vs := &clientgonetworkingv1alpha3.VirtualService{
 		Spec: strategy.Spec.Template.Spec,
 	}
 
 	// one version rules them all
 	if len(strategy.Spec.GovernorVersion) > 0 {
-		governorDestinationWeight := v1alpha3.DestinationWeight{
-			Destination: v1alpha3.Destination{
+		governorDestinationWeight := apinetworkingv1alpha3.HTTPRouteDestination{
+			Destination: &apinetworkingv1alpha3.Destination{
 				Host:   service.Name,
 				Subset: strategy.Spec.GovernorVersion,
 			},
@@ -541,16 +550,26 @@ func (v *VirtualServiceController) generateVirtualServiceSpec(strategy *servicem
 		}
 
 		if len(strategy.Spec.Template.Spec.Http) > 0 {
-			governorRoute := v1alpha3.HTTPRoute{
-				Route: []v1alpha3.DestinationWeight{governorDestinationWeight},
+			governorRoute := apinetworkingv1alpha3.HTTPRoute{
+				Route: []*apinetworkingv1alpha3.HTTPRouteDestination{&governorDestinationWeight},
 			}
 
-			vs.Spec.Http = []v1alpha3.HTTPRoute{governorRoute}
+			vs.Spec.Http = []*apinetworkingv1alpha3.HTTPRoute{&governorRoute}
 		} else if len(strategy.Spec.Template.Spec.Tcp) > 0 {
-			governorRoute := v1alpha3.TCPRoute{
-				Route: []v1alpha3.DestinationWeight{governorDestinationWeight},
+			tcpRoute := apinetworkingv1alpha3.TCPRoute{
+				Route: []*apinetworkingv1alpha3.RouteDestination{
+					{
+						Destination: &apinetworkingv1alpha3.Destination{
+							Host:   governorDestinationWeight.Destination.Host,
+							Subset: governorDestinationWeight.Destination.Subset,
+						},
+						Weight: governorDestinationWeight.Weight,
+					},
+				},
 			}
-			vs.Spec.Tcp = []v1alpha3.TCPRoute{governorRoute}
+
+			//governorRoute := v1alpha3.TCPRoute{tcpRoute}
+			vs.Spec.Tcp = []*apinetworkingv1alpha3.TCPRoute{&tcpRoute}
 		}
 
 	}

pkg/controller/workspace/workspace_controller.go

@@ -69,7 +69,7 @@ func Add(mgr manager.Manager) error {
 // newReconciler returns a new reconcile.Reconciler
 func newReconciler(mgr manager.Manager) reconcile.Reconciler {
 	return &ReconcileWorkspace{Client: mgr.GetClient(), scheme: mgr.GetScheme(),
-		recorder: mgr.GetRecorder("workspace-controller"), ksclient: cs.ClientSets().KubeSphere()}
+		recorder: mgr.GetEventRecorderFor("workspace-controller"), ksclient: cs.ClientSets().KubeSphere()}
 }
 
 // add adds a new Controller to mgr with r as the reconcile.Reconciler
@@ -498,7 +498,7 @@ func (r *ReconcileWorkspace) bindNamespaces(instance *tenantv1alpha1.Workspace)
 
 	nsList := &corev1.NamespaceList{}
 	options := client.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set{constants.WorkspaceLabelKey: instance.Name})}
-	err := r.List(context.TODO(), &options, nsList)
+	err := r.List(context.TODO(), nsList, &options)
 
 	if err != nil {
 		log.Error(err, fmt.Sprintf("list workspace %s namespace failed", instance.Name))

pkg/models/resources/nodes.go

@@ -53,10 +53,14 @@ func getNodeStatus(node *v1.Node) string {
 const NodeConfigOK v1.NodeConditionType = "ConfigOK"
 const NodeKubeletReady v1.NodeConditionType = "KubeletReady"
 
-var expectedConditions = map[v1.NodeConditionType]v1.ConditionStatus{v1.NodeOutOfDisk: v1.ConditionFalse,
-	v1.NodeMemoryPressure: v1.ConditionFalse, v1.NodeDiskPressure: v1.ConditionFalse, v1.NodePIDPressure: v1.ConditionFalse,
-	v1.NodeNetworkUnavailable: v1.ConditionFalse, NodeConfigOK: v1.ConditionTrue, NodeKubeletReady: v1.ConditionTrue,
-	v1.NodeReady: v1.ConditionTrue,
+var expectedConditions = map[v1.NodeConditionType]v1.ConditionStatus{
+	v1.NodeMemoryPressure:     v1.ConditionFalse,
+	v1.NodeDiskPressure:       v1.ConditionFalse,
+	v1.NodePIDPressure:        v1.ConditionFalse,
+	v1.NodeNetworkUnavailable: v1.ConditionFalse,
+	NodeConfigOK:              v1.ConditionTrue,
+	NodeKubeletReady:          v1.ConditionTrue,
+	v1.NodeReady:              v1.ConditionTrue,
 }
 
 func isUnhealthStatus(condition v1.NodeCondition) bool {

pkg/simple/client/fluentbit/fluentbitcrdclient.go

@@ -211,8 +211,7 @@ func NewFluentbitCRDClient(cfg *rest.Config) (*rest.RESTClient, *runtime.Scheme,
 	config.GroupVersion = &SchemeGroupVersion
 	config.APIPath = "/apis"
 	config.ContentType = runtime.ContentTypeJSON
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{
-		CodecFactory: serializer.NewCodecFactory(scheme)}
+	config.NegotiatedSerializer = serializer.NewCodecFactory(runtime.NewScheme()).WithoutConversion()
 
 	client, err := rest.RESTClientFor(&config)
 	if err != nil {

tools/lib/render.go

@@ -71,7 +71,7 @@ func RenderOpenAPISpec(cfg Config) (string, error) {
 
 	serverConfig := genericapiserver.NewRecommendedConfig(cfg.Codecs)
 
-	if err := recommendedOptions.ApplyTo(serverConfig, cfg.Scheme); err != nil {
+	if err := recommendedOptions.ApplyTo(serverConfig); err != nil {
 		log.Fatal(err)
 		return "", err
 	}

tools/lib/storage.go

@@ -74,12 +74,12 @@ func (r *StandardStorage) Update(ctx context.Context, name string, objInfo rest.
 }
 
 // GracefulDeleter
-func (r *StandardStorage) Delete(ctx context.Context, name string, options *metav1.DeleteOptions) (runtime.Object, bool, error) {
+func (r *StandardStorage) Delete(ctx context.Context, name string, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions) (runtime.Object, bool, error) {
 	return r.New(), true, nil
 }
 
 // CollectionDeleter
-func (r *StandardStorage) DeleteCollection(ctx context.Context, options *metav1.DeleteOptions, listOptions *metainternalversion.ListOptions) (runtime.Object, error) {
+func (r *StandardStorage) DeleteCollection(ctx context.Context, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions, listOptions *metainternalversion.ListOptions) (runtime.Object, error) {
 	return r.NewList(), nil
 }
 

vendor/cloud.google.com/go/AUTHORS

-# This is the official list of cloud authors for copyright purposes.
-# This file is distinct from the CONTRIBUTORS files.
-# See the latter for an explanation.
-
-# Names should be added to this file as:
-# Name or Organization <email address>
-# The email address is not required for organizations.
-
-Filippo Valsorda <hi@filippo.io>
-Google Inc.
-Ingo Oeser <nightlyone@googlemail.com>
-Palm Stone Games, Inc.
-Paweł Knap <pawelknap88@gmail.com>
-Péter Szilágyi <peterke@gmail.com>
-Tyler Treat <ttreat31@gmail.com>

vendor/cloud.google.com/go/CONTRIBUTORS

-# People who have agreed to one of the CLAs and can contribute patches.
-# The AUTHORS file lists the copyright holders; this file
-# lists people.  For example, Google employees are listed here
-# but not in AUTHORS, because Google holds the copyright.
-#
-# https://developers.google.com/open-source/cla/individual
-# https://developers.google.com/open-source/cla/corporate
-#
-# Names should be added to this file as:
-#     Name <email address>
-
-# Keep the list alphabetically sorted.
-
-Alexis Hunt <lexer@google.com>
-Andreas Litt <andreas.litt@gmail.com>
-Andrew Gerrand <adg@golang.org>
-Brad Fitzpatrick <bradfitz@golang.org>
-Burcu Dogan <jbd@google.com>
-Dave Day <djd@golang.org>
-David Sansome <me@davidsansome.com>
-David Symonds <dsymonds@golang.org>
-Filippo Valsorda <hi@filippo.io>
-Glenn Lewis <gmlewis@google.com>
-Ingo Oeser <nightlyone@googlemail.com>
-James Hall <james.hall@shopify.com>
-Johan Euphrosine <proppy@google.com>
-Jonathan Amsterdam <jba@google.com>
-Kunpei Sakai <namusyaka@gmail.com>
-Luna Duclos <luna.duclos@palmstonegames.com>
-Magnus Hiie <magnus.hiie@gmail.com>
-Mario Castro <mariocaster@gmail.com>
-Michael McGreevy <mcgreevy@golang.org>
-Omar Jarjur <ojarjur@google.com>
-Paweł Knap <pawelknap88@gmail.com>
-Péter Szilágyi <peterke@gmail.com>
-Sarah Adams <shadams@google.com>
-Thanatat Tamtan <acoshift@gmail.com>
-Toby Burress <kurin@google.com>
-Tuo Shan <shantuo@google.com>
-Tyler Treat <ttreat31@gmail.com>

vendor/cloud.google.com/go/compute/metadata/metadata.go

@@ -137,7 +137,7 @@ func testOnGCE() bool {
 	resc := make(chan bool, 2)
 
 	// Try two strategies in parallel.
-	// See https://github.com/GoogleCloudPlatform/google-cloud-go/issues/194
+	// See https://github.com/googleapis/google-cloud-go/issues/194
 	go func() {
 		req, _ := http.NewRequest("GET", "http://"+metadataIP, nil)
 		req.Header.Set("User-Agent", userAgent)
@@ -300,8 +300,8 @@ func (c *Client) getETag(suffix string) (value, etag string, err error) {
 		// being stable anyway.
 		host = metadataIP
 	}
-	url := "http://" + host + "/computeMetadata/v1/" + suffix
-	req, _ := http.NewRequest("GET", url, nil)
+	u := "http://" + host + "/computeMetadata/v1/" + suffix
+	req, _ := http.NewRequest("GET", u, nil)
 	req.Header.Set("Metadata-Flavor", "Google")
 	req.Header.Set("User-Agent", userAgent)
 	res, err := c.hc.Do(req)
@@ -312,13 +312,13 @@ func (c *Client) getETag(suffix string) (value, etag string, err error) {
 	if res.StatusCode == http.StatusNotFound {
 		return "", "", NotDefinedError(suffix)
 	}
-	if res.StatusCode != 200 {
-		return "", "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url)
-	}
 	all, err := ioutil.ReadAll(res.Body)
 	if err != nil {
 		return "", "", err
 	}
+	if res.StatusCode != 200 {
+		return "", "", &Error{Code: res.StatusCode, Message: string(all)}
+	}
 	return string(all), res.Header.Get("Etag"), nil
 }
 
@@ -499,3 +499,15 @@ func (c *Client) Subscribe(suffix string, fn func(v string, ok bool) error) erro
 		}
 	}
 }
+
+// Error contains an error response from the server.
+type Error struct {
+	// Code is the HTTP response status code.
+	Code int
+	// Message is the server response message.
+	Message string
+}
+
+func (e *Error) Error() string {
+	return fmt.Sprintf("compute: Received %d `%s`", e.Code, e.Message)
+}

vendor/contrib.go.opencensus.io/exporter/ocagent/.travis.yml

-language: go
-
-go:
-  - 1.11.x
-
-go_import_path: contrib.go.opencensus.io/exporter/ocagent
-
-before_script:
-  - GO_FILES=$(find . -iname '*.go' | grep -v /vendor/)  # All the .go files, excluding vendor/ if any
-  - PKGS=$(go list ./... | grep -v /vendor/)             # All the import paths, excluding vendor/ if any
-
-script:
-  - go build ./...                    # Ensure dependency updates don't break build
-  - if [ -n "$(gofmt -s -l $GO_FILES)" ]; then echo "gofmt the following files:"; gofmt -s -l $GO_FILES; exit 1; fi
-  - go vet ./...
-  - GO111MODULE=on go test -v -race $PKGS            # Run all the tests with the race detector enabled
-  - GO111MODULE=off go test -v -race $PKGS           # Make sure tests still pass when not using Go modules.
-  - 'if [[ $TRAVIS_GO_VERSION = 1.8* ]]; then ! golint ./... | grep -vE "(_mock|_string|\.pb)\.go:"; fi'

vendor/contrib.go.opencensus.io/exporter/ocagent/CONTRIBUTING.md

-# How to contribute
-
-We'd love to accept your patches and contributions to this project. There are
-just a few small guidelines you need to follow.
-
-## Contributor License Agreement
-
-Contributions to this project must be accompanied by a Contributor License
-Agreement. You (or your employer) retain the copyright to your contribution,
-this simply gives us permission to use and redistribute your contributions as
-part of the project. Head over to <https://cla.developers.google.com/> to see
-your current agreements on file or to sign a new one.
-
-You generally only need to submit a CLA once, so if you've already submitted one
-(even if it was for a different project), you probably don't need to do it
-again.
-
-## Code reviews
-
-All submissions, including submissions by project members, require review. We
-use GitHub pull requests for this purpose. Consult [GitHub Help] for more
-information on using pull requests.
-
-[GitHub Help]: https://help.github.com/articles/about-pull-requests/

vendor/contrib.go.opencensus.io/exporter/ocagent/README.md

-# OpenCensus Agent Go Exporter
-
-[![Build Status][travis-image]][travis-url] [![GoDoc][godoc-image]][godoc-url]
-
-
-This repository contains the Go implementation of the OpenCensus Agent (OC-Agent) Exporter.
-OC-Agent is a deamon process running in a VM that can retrieve spans/stats/metrics from
-OpenCensus Library, export them to other backends and possibly push configurations back to
-Library. See more details on [OC-Agent Readme][OCAgentReadme].
-
-Note: This is an experimental repository and is likely to get backwards-incompatible changes.
-Ultimately we may want to move the OC-Agent Go Exporter to [OpenCensus Go core library][OpenCensusGo].
-
-## Installation
-
-```bash
-$ go get -u contrib.go.opencensus.io/exporter/ocagent
-```
-
-## Usage
-
-```go
-import (
-	"context"
-	"fmt"
-	"log"
-	"time"
-
-	"contrib.go.opencensus.io/exporter/ocagent"
-	"go.opencensus.io/trace"
-)
-
-func Example() {
-	exp, err := ocagent.NewExporter(ocagent.WithInsecure(), ocagent.WithServiceName("your-service-name"))
-	if err != nil {
-		log.Fatalf("Failed to create the agent exporter: %v", err)
-	}
-	defer exp.Stop()
-
-	// Now register it as a trace exporter.
-	trace.RegisterExporter(exp)
-
-	// Then use the OpenCensus tracing library, like we normally would.
-	ctx, span := trace.StartSpan(context.Background(), "AgentExporter-Example")
-	defer span.End()
-
-	for i := 0; i < 10; i++ {
-		_, iSpan := trace.StartSpan(ctx, fmt.Sprintf("Sample-%d", i))
-		<-time.After(6 * time.Millisecond)
-		iSpan.End()
-	}
-}
-```
-
-[OCAgentReadme]: https://github.com/census-instrumentation/opencensus-proto/tree/master/opencensus/proto/agent#opencensus-agent-proto
-[OpenCensusGo]: https://github.com/census-instrumentation/opencensus-go
-[godoc-image]: https://godoc.org/contrib.go.opencensus.io/exporter/ocagent?status.svg
-[godoc-url]: https://godoc.org/contrib.go.opencensus.io/exporter/ocagent
-[travis-image]: https://travis-ci.org/census-ecosystem/opencensus-go-exporter-ocagent.svg?branch=master
-[travis-url]: https://travis-ci.org/census-ecosystem/opencensus-go-exporter-ocagent
-

vendor/contrib.go.opencensus.io/exporter/ocagent/go.mod

-module contrib.go.opencensus.io/exporter/ocagent
-
-require (
-	github.com/census-instrumentation/opencensus-proto v0.2.0 // this is to match the version used in census-instrumentation/opencensus-service
-	github.com/golang/protobuf v1.3.1
-	github.com/grpc-ecosystem/grpc-gateway v1.8.5 // indirect
-	go.opencensus.io v0.20.2
-	google.golang.org/api v0.3.1
-	google.golang.org/grpc v1.19.1
-)