Merge branch 'master' into master

Makefile

@@ -64,7 +64,7 @@ deploy: manifests
 
 # Generate DeepCopy to implement runtime.Object
 deepcopy:
-	./vendor/k8s.io/code-generator/generate-groups.sh deepcopy kubesphere.io/kubesphere/pkg/client kubesphere.io/kubesphere/pkg/apis "servicemesh:v1alpha2"
+	./vendor/k8s.io/code-generator/generate-groups.sh deepcopy,lister,informer,client kubesphere.io/kubesphere/pkg/client kubesphere.io/kubesphere/pkg/apis "servicemesh:v1alpha2"
 
 # Generate code
 generate:

cmd/controller-manager/app/controllers.go

@@ -56,6 +56,7 @@ func AddControllers(mgr manager.Manager, cfg *rest.Config, stopCh <-chan struct{
 	drController := destinationrule.NewDestinationRuleController(informerFactory.Apps().V1().Deployments(),
 		istioInformer.Networking().V1alpha3().DestinationRules(),
 		informerFactory.Core().V1().Services(),
+		servicemeshinformer.Servicemesh().V1alpha2().ServicePolicies(),
 		kubeClient,
 		istioclient)
 

config/samples/servicemesh_v1alpha2_servicepolicy.yaml

+apiVersion: servicemesh.kubesphere.io/v1alpha2
+kind: ServicePolicy
+metadata:
+  labels:
+    controller-tools.k8s.io: "1.0"
+  name: servicepolicy-sample
+spec:
+  # Add fields here
+  foo: bar

pkg/apis/servicemesh/v1alpha2/servicepolicy_types.go

+/*
+Copyright 2019 The KubeSphere authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1alpha2
+
+import (
+	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!
+// NOTE: json tags are required.  Any new fields you add must have json tags for the fields to be serialized.
+
+// ServicePolicySpec defines the desired state of ServicePolicy
+type ServicePolicySpec struct {
+
+	// Label selector for destination rules.
+	// +optional
+	Selector *metav1.LabelSelector `json:"selector,omitempty"`
+
+	// Template used to create a destination rule
+	// +optional
+	Template DestinationRuleSpecTemplate `json:"template,omitempty"`
+}
+
+type DestinationRuleSpecTemplate struct {
+
+	// Metadata of the virtual services created from this template
+	// +optional
+	metav1.ObjectMeta
+
+	// Spec indicates the behavior of a destination rule.
+	// +optional
+	Spec v1alpha3.DestinationRuleSpec `json:"spec,omitempty"`
+}
+
+type ServicePolicyConditionType string
+
+// These are valid conditions of a strategy.
+const (
+	// StrategyComplete means the strategy has been delivered to istio.
+	ServicePolicyComplete ServicePolicyConditionType = "Complete"
+
+	// StrategyFailed means the strategy has failed its delivery to istio.
+	ServicePolicyFailed ServicePolicyConditionType = "Failed"
+)
+
+// StrategyCondition describes current state of a strategy.
+type ServicePolicyCondition struct {
+	// Type of strategy condition, Complete or Failed.
+	Type ServicePolicyConditionType
+
+	// Status of the condition, one of True, False, Unknown
+	Status apiextensions.ConditionStatus
+
+	// Last time the condition was checked.
+	// +optional
+	LastProbeTime metav1.Time
+
+	// Last time the condition transit from one status to another
+	// +optional
+	LastTransitionTime metav1.Time
+
+	// reason for the condition's last transition
+	Reason string
+
+	// Human readable message indicating details about last transition.
+	// +optinal
+	Message string
+}
+
+// ServicePolicyStatus defines the observed state of ServicePolicy
+type ServicePolicyStatus struct {
+	// The latest available observations of an object's current state.
+	// +optional
+	Conditions []ServicePolicyCondition
+
+	// Represents time when the strategy was acknowledged by the controller.
+	// It is represented in RFC3339 form and is in UTC.
+	// +optional
+	StartTime *metav1.Time
+
+	// Represents time when the strategy was completed.
+	// It is represented in RFC3339 form and is in UTC.
+	// +optional
+	CompletionTime *metav1.Time
+}
+
+// +genclient
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// ServicePolicy is the Schema for the servicepolicies API
+// +k8s:openapi-gen=true
+type ServicePolicy struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   ServicePolicySpec   `json:"spec,omitempty"`
+	Status ServicePolicyStatus `json:"status,omitempty"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// ServicePolicyList contains a list of ServicePolicy
+type ServicePolicyList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []ServicePolicy `json:"items"`
+}
+
+func init() {
+	SchemeBuilder.Register(&ServicePolicy{}, &ServicePolicyList{})
+}

pkg/controller/strategy/strategy_controller_suite_test.go → pkg/apis/servicemesh/v1alpha2/servicepolicy_types_test.go

@@ -14,62 +14,45 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package strategy
+package v1alpha2
 
 import (
-	stdlog "log"
-	"os"
-	"path/filepath"
-	"sync"
 	"testing"
 
 	"github.com/onsi/gomega"
-	"k8s.io/client-go/kubernetes/scheme"
-	"k8s.io/client-go/rest"
-	"kubesphere.io/kubesphere/pkg/apis"
-	"sigs.k8s.io/controller-runtime/pkg/envtest"
-	"sigs.k8s.io/controller-runtime/pkg/manager"
-	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"golang.org/x/net/context"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
 )
 
-var cfg *rest.Config
-
-func TestMain(m *testing.M) {
-	t := &envtest.Environment{
-		CRDDirectoryPaths: []string{filepath.Join("..", "..", "..", "config", "crds")},
-	}
-	apis.AddToScheme(scheme.Scheme)
-
-	var err error
-	if cfg, err = t.Start(); err != nil {
-		stdlog.Fatal(err)
+func TestStorageServicePolicy(t *testing.T) {
+	key := types.NamespacedName{
+		Name:      "foo",
+		Namespace: "default",
 	}
-
-	code := m.Run()
-	t.Stop()
-	os.Exit(code)
-}
-
-// SetupTestReconcile returns a reconcile.Reconcile implementation that delegates to inner and
-// writes the request to requests after Reconcile is finished.
-func SetupTestReconcile(inner reconcile.Reconciler) (reconcile.Reconciler, chan reconcile.Request) {
-	requests := make(chan reconcile.Request)
-	fn := reconcile.Func(func(req reconcile.Request) (reconcile.Result, error) {
-		result, err := inner.Reconcile(req)
-		requests <- req
-		return result, err
-	})
-	return fn, requests
-}
-
-// StartTestManager adds recFn
-func StartTestManager(mgr manager.Manager, g *gomega.GomegaWithT) (chan struct{}, *sync.WaitGroup) {
-	stop := make(chan struct{})
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		g.Expect(mgr.Start(stop)).NotTo(gomega.HaveOccurred())
-	}()
-	return stop, wg
+	created := &ServicePolicy{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo",
+			Namespace: "default",
+		}}
+	g := gomega.NewGomegaWithT(t)
+
+	// Test Create
+	fetched := &ServicePolicy{}
+	g.Expect(c.Create(context.TODO(), created)).NotTo(gomega.HaveOccurred())
+
+	g.Expect(c.Get(context.TODO(), key, fetched)).NotTo(gomega.HaveOccurred())
+	g.Expect(fetched).To(gomega.Equal(created))
+
+	// Test Updating the Labels
+	updated := fetched.DeepCopy()
+	updated.Labels = map[string]string{"hello": "world"}
+	g.Expect(c.Update(context.TODO(), updated)).NotTo(gomega.HaveOccurred())
+
+	g.Expect(c.Get(context.TODO(), key, fetched)).NotTo(gomega.HaveOccurred())
+	g.Expect(fetched).To(gomega.Equal(updated))
+
+	// Test Delete
+	g.Expect(c.Delete(context.TODO(), fetched)).NotTo(gomega.HaveOccurred())
+	g.Expect(c.Get(context.TODO(), key, fetched)).To(gomega.HaveOccurred())
 }

pkg/apis/servicemesh/v1alpha2/zz_generated.deepcopy.go

@@ -25,6 +25,156 @@ import (
 	runtime "k8s.io/apimachinery/pkg/runtime"
 )
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *DestinationRuleSpecTemplate) DeepCopyInto(out *DestinationRuleSpecTemplate) {
+	*out = *in
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DestinationRuleSpecTemplate.
+func (in *DestinationRuleSpecTemplate) DeepCopy() *DestinationRuleSpecTemplate {
+	if in == nil {
+		return nil
+	}
+	out := new(DestinationRuleSpecTemplate)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServicePolicy) DeepCopyInto(out *ServicePolicy) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	in.Status.DeepCopyInto(&out.Status)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServicePolicy.
+func (in *ServicePolicy) DeepCopy() *ServicePolicy {
+	if in == nil {
+		return nil
+	}
+	out := new(ServicePolicy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *ServicePolicy) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServicePolicyCondition) DeepCopyInto(out *ServicePolicyCondition) {
+	*out = *in
+	in.LastProbeTime.DeepCopyInto(&out.LastProbeTime)
+	in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServicePolicyCondition.
+func (in *ServicePolicyCondition) DeepCopy() *ServicePolicyCondition {
+	if in == nil {
+		return nil
+	}
+	out := new(ServicePolicyCondition)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServicePolicyList) DeepCopyInto(out *ServicePolicyList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]ServicePolicy, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServicePolicyList.
+func (in *ServicePolicyList) DeepCopy() *ServicePolicyList {
+	if in == nil {
+		return nil
+	}
+	out := new(ServicePolicyList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *ServicePolicyList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServicePolicySpec) DeepCopyInto(out *ServicePolicySpec) {
+	*out = *in
+	if in.Selector != nil {
+		in, out := &in.Selector, &out.Selector
+		*out = new(v1.LabelSelector)
+		(*in).DeepCopyInto(*out)
+	}
+	in.Template.DeepCopyInto(&out.Template)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServicePolicySpec.
+func (in *ServicePolicySpec) DeepCopy() *ServicePolicySpec {
+	if in == nil {
+		return nil
+	}
+	out := new(ServicePolicySpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ServicePolicyStatus) DeepCopyInto(out *ServicePolicyStatus) {
+	*out = *in
+	if in.Conditions != nil {
+		in, out := &in.Conditions, &out.Conditions
+		*out = make([]ServicePolicyCondition, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.StartTime != nil {
+		in, out := &in.StartTime, &out.StartTime
+		*out = (*in).DeepCopy()
+	}
+	if in.CompletionTime != nil {
+		in, out := &in.CompletionTime, &out.CompletionTime
+		*out = (*in).DeepCopy()
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServicePolicyStatus.
+func (in *ServicePolicyStatus) DeepCopy() *ServicePolicyStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(ServicePolicyStatus)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *Strategy) DeepCopyInto(out *Strategy) {
 	*out = *in

pkg/client/clientset/versioned/typed/servicemesh/v1alpha2/fake/fake_servicemesh_client.go

@@ -28,6 +28,10 @@ type FakeServicemeshV1alpha2 struct {
 	*testing.Fake
 }
 
+func (c *FakeServicemeshV1alpha2) ServicePolicies(namespace string) v1alpha2.ServicePolicyInterface {
+	return &FakeServicePolicies{c, namespace}
+}
+
 func (c *FakeServicemeshV1alpha2) Strategies(namespace string) v1alpha2.StrategyInterface {
 	return &FakeStrategies{c, namespace}
 }

pkg/client/clientset/versioned/typed/servicemesh/v1alpha2/fake/fake_servicepolicy.go

+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+	v1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
+)
+
+// FakeServicePolicies implements ServicePolicyInterface
+type FakeServicePolicies struct {
+	Fake *FakeServicemeshV1alpha2
+	ns   string
+}
+
+var servicepoliciesResource = schema.GroupVersionResource{Group: "servicemesh.kubesphere.io", Version: "v1alpha2", Resource: "servicepolicies"}
+
+var servicepoliciesKind = schema.GroupVersionKind{Group: "servicemesh.kubesphere.io", Version: "v1alpha2", Kind: "ServicePolicy"}
+
+// Get takes name of the servicePolicy, and returns the corresponding servicePolicy object, and an error if there is any.
+func (c *FakeServicePolicies) Get(name string, options v1.GetOptions) (result *v1alpha2.ServicePolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(servicepoliciesResource, c.ns, name), &v1alpha2.ServicePolicy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha2.ServicePolicy), err
+}
+
+// List takes label and field selectors, and returns the list of ServicePolicies that match those selectors.
+func (c *FakeServicePolicies) List(opts v1.ListOptions) (result *v1alpha2.ServicePolicyList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(servicepoliciesResource, servicepoliciesKind, c.ns, opts), &v1alpha2.ServicePolicyList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1alpha2.ServicePolicyList{ListMeta: obj.(*v1alpha2.ServicePolicyList).ListMeta}
+	for _, item := range obj.(*v1alpha2.ServicePolicyList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested servicePolicies.
+func (c *FakeServicePolicies) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(servicepoliciesResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a servicePolicy and creates it.  Returns the server's representation of the servicePolicy, and an error, if there is any.
+func (c *FakeServicePolicies) Create(servicePolicy *v1alpha2.ServicePolicy) (result *v1alpha2.ServicePolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(servicepoliciesResource, c.ns, servicePolicy), &v1alpha2.ServicePolicy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha2.ServicePolicy), err
+}
+
+// Update takes the representation of a servicePolicy and updates it. Returns the server's representation of the servicePolicy, and an error, if there is any.
+func (c *FakeServicePolicies) Update(servicePolicy *v1alpha2.ServicePolicy) (result *v1alpha2.ServicePolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(servicepoliciesResource, c.ns, servicePolicy), &v1alpha2.ServicePolicy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha2.ServicePolicy), err
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+func (c *FakeServicePolicies) UpdateStatus(servicePolicy *v1alpha2.ServicePolicy) (*v1alpha2.ServicePolicy, error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateSubresourceAction(servicepoliciesResource, "status", c.ns, servicePolicy), &v1alpha2.ServicePolicy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha2.ServicePolicy), err
+}
+
+// Delete takes name of the servicePolicy and deletes it. Returns an error if one occurs.
+func (c *FakeServicePolicies) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteAction(servicepoliciesResource, c.ns, name), &v1alpha2.ServicePolicy{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeServicePolicies) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(servicepoliciesResource, c.ns, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1alpha2.ServicePolicyList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched servicePolicy.
+func (c *FakeServicePolicies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha2.ServicePolicy, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(servicepoliciesResource, c.ns, name, pt, data, subresources...), &v1alpha2.ServicePolicy{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1alpha2.ServicePolicy), err
+}

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

@@ -18,4 +18,6 @@ limitations under the License.
 
 package v1alpha2
 
+type ServicePolicyExpansion interface{}
+
 type StrategyExpansion interface{}

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

@@ -27,6 +27,7 @@ import (
 
 type ServicemeshV1alpha2Interface interface {
 	RESTClient() rest.Interface
+	ServicePoliciesGetter
 	StrategiesGetter
 }
 
@@ -35,6 +36,10 @@ type ServicemeshV1alpha2Client struct {
 	restClient rest.Interface
 }
 
+func (c *ServicemeshV1alpha2Client) ServicePolicies(namespace string) ServicePolicyInterface {
+	return newServicePolicies(c, namespace)
+}
+
 func (c *ServicemeshV1alpha2Client) Strategies(namespace string) StrategyInterface {
 	return newStrategies(c, namespace)
 }

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

+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	"time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	rest "k8s.io/client-go/rest"
+	v1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
+	scheme "kubesphere.io/kubesphere/pkg/client/clientset/versioned/scheme"
+)
+
+// ServicePoliciesGetter has a method to return a ServicePolicyInterface.
+// A group's client should implement this interface.
+type ServicePoliciesGetter interface {
+	ServicePolicies(namespace string) ServicePolicyInterface
+}
+
+// ServicePolicyInterface has methods to work with ServicePolicy resources.
+type ServicePolicyInterface interface {
+	Create(*v1alpha2.ServicePolicy) (*v1alpha2.ServicePolicy, error)
+	Update(*v1alpha2.ServicePolicy) (*v1alpha2.ServicePolicy, error)
+	UpdateStatus(*v1alpha2.ServicePolicy) (*v1alpha2.ServicePolicy, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*v1alpha2.ServicePolicy, error)
+	List(opts v1.ListOptions) (*v1alpha2.ServicePolicyList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha2.ServicePolicy, err error)
+	ServicePolicyExpansion
+}
+
+// servicePolicies implements ServicePolicyInterface
+type servicePolicies struct {
+	client rest.Interface
+	ns     string
+}
+
+// newServicePolicies returns a ServicePolicies
+func newServicePolicies(c *ServicemeshV1alpha2Client, namespace string) *servicePolicies {
+	return &servicePolicies{
+		client: c.RESTClient(),
+		ns:     namespace,
+	}
+}
+
+// Get takes name of the servicePolicy, and returns the corresponding servicePolicy object, and an error if there is any.
+func (c *servicePolicies) Get(name string, options v1.GetOptions) (result *v1alpha2.ServicePolicy, err error) {
+	result = &v1alpha2.ServicePolicy{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of ServicePolicies that match those selectors.
+func (c *servicePolicies) List(opts v1.ListOptions) (result *v1alpha2.ServicePolicyList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &v1alpha2.ServicePolicyList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested servicePolicies.
+func (c *servicePolicies) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch()
+}
+
+// Create takes the representation of a servicePolicy and creates it.  Returns the server's representation of the servicePolicy, and an error, if there is any.
+func (c *servicePolicies) Create(servicePolicy *v1alpha2.ServicePolicy) (result *v1alpha2.ServicePolicy, err error) {
+	result = &v1alpha2.ServicePolicy{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		Body(servicePolicy).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a servicePolicy and updates it. Returns the server's representation of the servicePolicy, and an error, if there is any.
+func (c *servicePolicies) Update(servicePolicy *v1alpha2.ServicePolicy) (result *v1alpha2.ServicePolicy, err error) {
+	result = &v1alpha2.ServicePolicy{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		Name(servicePolicy.Name).
+		Body(servicePolicy).
+		Do().
+		Into(result)
+	return
+}
+
+// UpdateStatus was generated because the type contains a Status member.
+// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
+
+func (c *servicePolicies) UpdateStatus(servicePolicy *v1alpha2.ServicePolicy) (result *v1alpha2.ServicePolicy, err error) {
+	result = &v1alpha2.ServicePolicy{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		Name(servicePolicy.Name).
+		SubResource("status").
+		Body(servicePolicy).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the servicePolicy and deletes it. Returns an error if one occurs.
+func (c *servicePolicies) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *servicePolicies) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	var timeout time.Duration
+	if listOptions.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched servicePolicy.
+func (c *servicePolicies) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha2.ServicePolicy, err error) {
+	result = &v1alpha2.ServicePolicy{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("servicepolicies").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}

pkg/client/informers/externalversions/generic.go

@@ -53,6 +53,8 @@ func (f *genericInformer) Lister() cache.GenericLister {
 func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
 	switch resource {
 	// Group=servicemesh.kubesphere.io, Version=v1alpha2
+	case v1alpha2.SchemeGroupVersion.WithResource("servicepolicies"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Servicemesh().V1alpha2().ServicePolicies().Informer()}, nil
 	case v1alpha2.SchemeGroupVersion.WithResource("strategies"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Servicemesh().V1alpha2().Strategies().Informer()}, nil
 

pkg/client/informers/externalversions/servicemesh/v1alpha2/interface.go

@@ -24,6 +24,8 @@ import (
 
 // Interface provides access to all the informers in this group version.
 type Interface interface {
+	// ServicePolicies returns a ServicePolicyInformer.
+	ServicePolicies() ServicePolicyInformer
 	// Strategies returns a StrategyInformer.
 	Strategies() StrategyInformer
 }
@@ -39,6 +41,11 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
 }
 
+// ServicePolicies returns a ServicePolicyInformer.
+func (v *version) ServicePolicies() ServicePolicyInformer {
+	return &servicePolicyInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
 // Strategies returns a StrategyInformer.
 func (v *version) Strategies() StrategyInformer {
 	return &strategyInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}

pkg/client/informers/externalversions/servicemesh/v1alpha2/servicepolicy.go

+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	cache "k8s.io/client-go/tools/cache"
+	servicemeshv1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
+	versioned "kubesphere.io/kubesphere/pkg/client/clientset/versioned"
+	internalinterfaces "kubesphere.io/kubesphere/pkg/client/informers/externalversions/internalinterfaces"
+	v1alpha2 "kubesphere.io/kubesphere/pkg/client/listers/servicemesh/v1alpha2"
+)
+
+// ServicePolicyInformer provides access to a shared informer and lister for
+// ServicePolicies.
+type ServicePolicyInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.ServicePolicyLister
+}
+
+type servicePolicyInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewServicePolicyInformer constructs a new informer for ServicePolicy type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewServicePolicyInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredServicePolicyInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredServicePolicyInformer constructs a new informer for ServicePolicy type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredServicePolicyInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ServicemeshV1alpha2().ServicePolicies(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ServicemeshV1alpha2().ServicePolicies(namespace).Watch(options)
+			},
+		},
+		&servicemeshv1alpha2.ServicePolicy{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *servicePolicyInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredServicePolicyInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *servicePolicyInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&servicemeshv1alpha2.ServicePolicy{}, f.defaultInformer)
+}
+
+func (f *servicePolicyInformer) Lister() v1alpha2.ServicePolicyLister {
+	return v1alpha2.NewServicePolicyLister(f.Informer().GetIndexer())
+}

pkg/client/listers/servicemesh/v1alpha2/expansion_generated.go

@@ -18,6 +18,14 @@ limitations under the License.
 
 package v1alpha2
 
+// ServicePolicyListerExpansion allows custom methods to be added to
+// ServicePolicyLister.
+type ServicePolicyListerExpansion interface{}
+
+// ServicePolicyNamespaceListerExpansion allows custom methods to be added to
+// ServicePolicyNamespaceLister.
+type ServicePolicyNamespaceListerExpansion interface{}
+
 // StrategyListerExpansion allows custom methods to be added to
 // StrategyLister.
 type StrategyListerExpansion interface{}

pkg/client/listers/servicemesh/v1alpha2/servicepolicy.go

+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+	v1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
+)
+
+// ServicePolicyLister helps list ServicePolicies.
+type ServicePolicyLister interface {
+	// List lists all ServicePolicies in the indexer.
+	List(selector labels.Selector) (ret []*v1alpha2.ServicePolicy, err error)
+	// ServicePolicies returns an object that can list and get ServicePolicies.
+	ServicePolicies(namespace string) ServicePolicyNamespaceLister
+	ServicePolicyListerExpansion
+}
+
+// servicePolicyLister implements the ServicePolicyLister interface.
+type servicePolicyLister struct {
+	indexer cache.Indexer
+}
+
+// NewServicePolicyLister returns a new ServicePolicyLister.
+func NewServicePolicyLister(indexer cache.Indexer) ServicePolicyLister {
+	return &servicePolicyLister{indexer: indexer}
+}
+
+// List lists all ServicePolicies in the indexer.
+func (s *servicePolicyLister) List(selector labels.Selector) (ret []*v1alpha2.ServicePolicy, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*v1alpha2.ServicePolicy))
+	})
+	return ret, err
+}
+
+// ServicePolicies returns an object that can list and get ServicePolicies.
+func (s *servicePolicyLister) ServicePolicies(namespace string) ServicePolicyNamespaceLister {
+	return servicePolicyNamespaceLister{indexer: s.indexer, namespace: namespace}
+}
+
+// ServicePolicyNamespaceLister helps list and get ServicePolicies.
+type ServicePolicyNamespaceLister interface {
+	// List lists all ServicePolicies in the indexer for a given namespace.
+	List(selector labels.Selector) (ret []*v1alpha2.ServicePolicy, err error)
+	// Get retrieves the ServicePolicy from the indexer for a given namespace and name.
+	Get(name string) (*v1alpha2.ServicePolicy, error)
+	ServicePolicyNamespaceListerExpansion
+}
+
+// servicePolicyNamespaceLister implements the ServicePolicyNamespaceLister
+// interface.
+type servicePolicyNamespaceLister struct {
+	indexer   cache.Indexer
+	namespace string
+}
+
+// List lists all ServicePolicies in the indexer for a given namespace.
+func (s servicePolicyNamespaceLister) List(selector labels.Selector) (ret []*v1alpha2.ServicePolicy, err error) {
+	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
+		ret = append(ret, m.(*v1alpha2.ServicePolicy))
+	})
+	return ret, err
+}
+
+// Get retrieves the ServicePolicy from the indexer for a given namespace and name.
+func (s servicePolicyNamespaceLister) Get(name string) (*v1alpha2.ServicePolicy, error) {
+	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(v1alpha2.Resource("servicepolicy"), name)
+	}
+	return obj.(*v1alpha2.ServicePolicy), nil
+}

pkg/controller/add_strategy.go

@@ -17,13 +17,12 @@ limitations under the License.
 package controller
 
 import (
-	"kubesphere.io/kubesphere/pkg/controller/strategy"
 	"sigs.k8s.io/application/pkg/controller/application"
 )
 
 func init() {
 	// AddToManagerFuncs is a list of functions to create controllers and add them to a manager.
-	AddToManagerFuncs = append(AddToManagerFuncs, strategy.Add)
+	//AddToManagerFuncs = append(AddToManagerFuncs, strategy.Add)
 
 	// Add application to manager functions
 	AddToManagerFuncs = append(AddToManagerFuncs, application.Add)

pkg/controller/destinationrule/destinationrule_controller.go

@@ -16,6 +16,7 @@ import (
 	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/util/metrics"
+	servicemeshv1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
 	"kubesphere.io/kubesphere/pkg/controller/virtualservice/util"
 	"reflect"
 	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
@@ -32,6 +33,9 @@ import (
 	"k8s.io/client-go/tools/record"
 	"k8s.io/client-go/util/workqueue"
 	"time"
+
+	servicemeshinformers "kubesphere.io/kubesphere/pkg/client/informers/externalversions/servicemesh/v1alpha2"
+	servicemeshlisters "kubesphere.io/kubesphere/pkg/client/listers/servicemesh/v1alpha2"
 )
 
 const (
@@ -59,6 +63,9 @@ type DestinationRuleController struct {
 	deploymentLister listersv1.DeploymentLister
 	deploymentSynced cache.InformerSynced
 
+	servicePolicyLister servicemeshlisters.ServicePolicyLister
+	servicePolicySynced cache.InformerSynced
+
 	destinationRuleLister istiolisters.DestinationRuleLister
 	destinationRuleSynced cache.InformerSynced
 
@@ -70,6 +77,7 @@ type DestinationRuleController struct {
 func NewDestinationRuleController(deploymentInformer informersv1.DeploymentInformer,
 	destinationRuleInformer istioinformers.DestinationRuleInformer,
 	serviceInformer coreinformers.ServiceInformer,
+	servicePolicyInformer servicemeshinformers.ServicePolicyInformer,
 	client clientset.Interface,
 	destinationRuleClient istioclientset.Interface) *DestinationRuleController {
 
@@ -116,6 +124,17 @@ func NewDestinationRuleController(deploymentInformer informersv1.DeploymentInfor
 	v.destinationRuleLister = destinationRuleInformer.Lister()
 	v.destinationRuleSynced = destinationRuleInformer.Informer().HasSynced
 
+	v.servicePolicyLister = servicePolicyInformer.Lister()
+	v.servicePolicySynced = servicePolicyInformer.Informer().HasSynced
+
+	servicePolicyInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
+		AddFunc: v.addServicePolicy,
+		UpdateFunc: func(old, cur interface{}) {
+			v.addServicePolicy(cur)
+		},
+		DeleteFunc: v.addServicePolicy,
+	})
+
 	v.eventBroadcaster = broadcaster
 	v.eventRecorder = recorder
 
@@ -136,7 +155,7 @@ func (v *DestinationRuleController) Run(workers int, stopCh <-chan struct{}) {
 	log.Info("starting destinationrule controller")
 	defer log.Info("shutting down destinationrule controller")
 
-	if !controller.WaitForCacheSync("destinationrule-controller", stopCh, v.serviceSynced, v.destinationRuleSynced, v.deploymentSynced) {
+	if !controller.WaitForCacheSync("destinationrule-controller", stopCh, v.serviceSynced, v.destinationRuleSynced, v.deploymentSynced, v.servicePolicySynced) {
 		return
 	}
 
@@ -177,6 +196,8 @@ func (v *DestinationRuleController) processNextWorkItem() bool {
 	return true
 }
 
+// main function of the reconcile for destinationrule
+// destinationrule's name is same with the service that created it
 func (v *DestinationRuleController) syncService(key string) error {
 	startTime := time.Now()
 	defer func() {
@@ -192,14 +213,14 @@ func (v *DestinationRuleController) syncService(key string) error {
 	if err != nil {
 		// Delete the corresponding destinationrule, as the service has been deleted.
 		err = v.destinationRuleClient.NetworkingV1alpha3().DestinationRules(namespace).Delete(name, nil)
-		if err != nil && !errors.IsNotFound(err) {
+		if !errors.IsNotFound(err) {
+			log.Error(err, "delete destination rule failed", "namespace", namespace, "name", name)
 			return err
 		}
-
 		return nil
 	}
 
-	if len(service.Labels) < len(util.ApplicationLabels) || !util.IsApplicationComponent(&service.ObjectMeta) ||
+	if len(service.Labels) < len(util.ApplicationLabels) || !util.IsApplicationComponent(service.Labels) ||
 		len(service.Spec.Ports) == 0 {
 		// services don't have enough labels to create a virtualservice
 		// or they don't have necessary labels
@@ -207,14 +228,22 @@ func (v *DestinationRuleController) syncService(key string) error {
 		return nil
 	}
 
+	appName := util.GetComponentName(&service.ObjectMeta)
+
+	// fetch all deployments that match with service selector
 	deployments, err := v.deploymentLister.Deployments(namespace).List(labels.Set(service.Spec.Selector).AsSelectorPreValidated())
 	if err != nil {
 		return err
 	}
 
-	subsets := []v1alpha3.Subset{}
+	subsets := make([]v1alpha3.Subset, 0)
 	for _, deployment := range deployments {
 
+		// not a valid deployment we required
+		if !util.IsApplicationComponent(deployment.Labels) || !util.IsApplicationComponent(deployment.Spec.Selector.MatchLabels) {
+			continue
+		}
+
 		version := util.GetComponentVersion(&deployment.ObjectMeta)
 
 		if len(version) == 0 {
@@ -248,19 +277,49 @@ func (v *DestinationRuleController) syncService(key string) error {
 			log.Error(err, "Couldn't get destinationrule for service", "key", key)
 			return err
 		}
+	}
 
+	// fetch all servicepolicies associated to this service
+	servicePolicies, err := v.servicePolicyLister.ServicePolicies(namespace).List(labels.SelectorFromSet(map[string]string{util.AppLabel: appName}))
+	if err != nil {
+		log.Error(err, "could not list service policies is namespace with component name", "namespace", namespace, "name", appName)
+		return err
+	}
+
+	dr := currentDestinationRule.DeepCopy()
+	dr.Spec.Subsets = subsets
+	//
+	if len(servicePolicies) > 0 {
+		if len(servicePolicies) > 1 {
+			err = fmt.Errorf("more than one service policy associated with service %s/%s is forbidden", namespace, name)
+			log.Error(err, "")
+			return err
+		}
+
+		sp := servicePolicies[0]
+		if sp.Spec.Template.Spec.TrafficPolicy != nil {
+			dr.Spec.TrafficPolicy = sp.Spec.Template.Spec.TrafficPolicy
+		}
+
+		for _, subset := range sp.Spec.Template.Spec.Subsets {
+			for i := range dr.Spec.Subsets {
+				if subset.Name == dr.Spec.Subsets[i].Name && subset.TrafficPolicy != nil {
+					dr.Spec.Subsets[i].TrafficPolicy = subset.TrafficPolicy
+				}
+			}
+		}
 	}
 
 	createDestinationRule := len(currentDestinationRule.ResourceVersion) == 0
 
-	if !createDestinationRule && reflect.DeepEqual(currentDestinationRule.Spec.Subsets, subsets) &&
+	if !createDestinationRule && reflect.DeepEqual(currentDestinationRule.Spec, dr.Spec) &&
 		reflect.DeepEqual(currentDestinationRule.Labels, service.Labels) {
 		log.V(5).Info("destinationrule are equal, skipping update", "key", types.NamespacedName{Namespace: service.Namespace, Name: service.Name}.String())
 		return nil
 	}
 
 	newDestinationRule := currentDestinationRule.DeepCopy()
-	newDestinationRule.Spec.Subsets = subsets
+	newDestinationRule.Spec = dr.Spec
 	newDestinationRule.Labels = service.Labels
 	if newDestinationRule.Annotations == nil {
 		newDestinationRule.Annotations = make(map[string]string)
@@ -293,20 +352,13 @@ func (v *DestinationRuleController) syncService(key string) error {
 	return nil
 }
 
-func (v *DestinationRuleController) isApplicationComponent(meta *metav1.ObjectMeta) bool {
-	if len(meta.Labels) >= len(util.ApplicationLabels) && util.IsApplicationComponent(meta) {
-		return true
-	}
-	return false
-}
-
 // When a destinationrule is added, figure out which service it will be used
 // and enqueue it. obj must have *appsv1.Deployment type
 func (v *DestinationRuleController) addDeployment(obj interface{}) {
 	deploy := obj.(*appsv1.Deployment)
 
 	// not a application component
-	if !v.isApplicationComponent(&deploy.ObjectMeta) {
+	if !util.IsApplicationComponent(deploy.Labels) || !util.IsApplicationComponent(deploy.Spec.Selector.MatchLabels) {
 		return
 	}
 
@@ -354,7 +406,7 @@ func (v *DestinationRuleController) getDeploymentServiceMemberShip(deployment *a
 
 	for i := range allServices {
 		service := allServices[i]
-		if service.Spec.Selector == nil || !v.isApplicationComponent(&service.ObjectMeta) {
+		if service.Spec.Selector == nil || !util.IsApplicationComponent(service.Labels) {
 			// services with nil selectors match nothing, not everything.
 			continue
 		}
@@ -371,6 +423,34 @@ func (v *DestinationRuleController) getDeploymentServiceMemberShip(deployment *a
 	return set, nil
 }
 
+func (v *DestinationRuleController) addServicePolicy(obj interface{}) {
+	servicePolicy := obj.(*servicemeshv1alpha2.ServicePolicy)
+
+	appName := servicePolicy.Labels[util.AppLabel]
+
+	services, err := v.serviceLister.Services(servicePolicy.Namespace).List(labels.SelectorFromSet(map[string]string{util.AppLabel: appName}))
+	if err != nil {
+		log.Error(err, "cannot list services", "namespace", servicePolicy.Namespace, "name", appName)
+		utilruntime.HandleError(fmt.Errorf("cannot list services in namespace %s, with component name %v", servicePolicy.Namespace, appName))
+		return
+	}
+
+	set := sets.String{}
+	for _, service := range services {
+		key, err := controller.KeyFunc(service)
+		if err != nil {
+			utilruntime.HandleError(err)
+			continue
+		}
+		set.Insert(key)
+	}
+
+	// avoid enqueue a key multiple times
+	for key := range set {
+		v.queue.Add(key)
+	}
+}
+
 func (v *DestinationRuleController) handleErr(err error, key interface{}) {
 	if err != nil {
 		v.queue.Forget(key)
@@ -383,7 +463,7 @@ func (v *DestinationRuleController) handleErr(err error, key interface{}) {
 		return
 	}
 
-	log.V(0).Info("Dropping service out of the queue", "key", key, "error", err)
+	log.V(4).Info("Dropping service out of the queue", "key", key, "error", err)
 	v.queue.Forget(key)
 	utilruntime.HandleError(err)
 }

pkg/controller/destinationrule/destinationrule_controller_test.go

 package destinationrule
+
+import (
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// 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 service = corev1.Service{}
+
+var deployments = []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",
+			},
+		},
+		Spec: appsv1.DeploymentSpec{
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{
+					"app.kubernetes.io/name":            "bookinfo",
+					"servicemesh.kubesphere.io/enabled": "",
+					"app":                               "reviews",
+					"version":                           "v1",
+				},
+			},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"app.kubernetes.io/name":            "bookinfo",
+						"servicemesh.kubesphere.io/enabled": "",
+						"app":                               "reviews",
+						"version":                           "v1",
+					},
+				},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{
+						{},
+					},
+				},
+			},
+		},
+	},
+}

pkg/controller/strategy/helper.go

-package strategy
-
-import (
-	"fmt"
-	"github.com/knative/pkg/apis/istio/v1alpha3"
-	"k8s.io/api/core/v1"
-	"kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
-)
-
-const (
-	AppLabel = "app"
-)
-
-func getAppNameByStrategy(strategy *v1alpha2.Strategy) string {
-	if len(strategy.Labels) > 0 && len(strategy.Labels[AppLabel]) > 0 {
-		return strategy.Labels[AppLabel]
-	}
-	return ""
-}
-
-// if virtualservice not specified with port number, then fill with service first port
-func fillDestinationPort(vs *v1alpha3.VirtualService, service *v1.Service) error {
-
-	if len(service.Spec.Ports) == 0 {
-		return fmt.Errorf("service %s/%s spec doesn't canotain any ports", service.Namespace, service.Name)
-	}
-
-	// 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)
-			}
-		}
-
-		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)
-		}
-	}
-
-	// fill tcp port
-	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)
-			}
-		}
-	}
-
-	return nil
-}

pkg/controller/strategy/strategy_controller.go

-/*
-Copyright 2019 The KubeSphere authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package strategy
-
-import (
-	"context"
-	"fmt"
-	"github.com/knative/pkg/apis/istio/v1alpha3"
-	"k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/types"
-	servicemeshv1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
-	"reflect"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/controller"
-	"sigs.k8s.io/controller-runtime/pkg/handler"
-	"sigs.k8s.io/controller-runtime/pkg/manager"
-	"sigs.k8s.io/controller-runtime/pkg/reconcile"
-	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
-	"sigs.k8s.io/controller-runtime/pkg/source"
-)
-
-var log = logf.Log.WithName("strategy-controller")
-
-// Add creates a new Strategy Controller and adds it to the Manager with default RBAC. The Manager will set fields on the Controller
-// and Start it when the Manager is Started.
-func Add(mgr manager.Manager) error {
-	return add(mgr, newReconciler(mgr))
-}
-
-// newReconciler returns a new reconcile.Reconciler
-func newReconciler(mgr manager.Manager) reconcile.Reconciler {
-	return &ReconcileStrategy{Client: mgr.GetClient(), scheme: mgr.GetScheme()}
-}
-
-// add adds a new Controller to mgr with r as the reconcile.Reconciler
-func add(mgr manager.Manager, r reconcile.Reconciler) error {
-	// Create a new controller
-	c, err := controller.New("strategy-controller", mgr, controller.Options{Reconciler: r})
-	if err != nil {
-		return err
-	}
-
-	// Watch for changes to Strategy
-	err = c.Watch(&source.Kind{Type: &servicemeshv1alpha2.Strategy{}}, &handler.EnqueueRequestForObject{})
-	if err != nil {
-		return err
-	}
-
-	// TODO(user): Modify this to be the types you create
-	// Watch a VirtualService created by Strategy
-	err = c.Watch(&source.Kind{Type: &v1alpha3.VirtualService{}}, &handler.EnqueueRequestForOwner{
-		IsController: true,
-		OwnerType:    &servicemeshv1alpha2.Strategy{},
-	})
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-var _ reconcile.Reconciler = &ReconcileStrategy{}
-
-// ReconcileStrategy reconciles a Strategy object
-type ReconcileStrategy struct {
-	client.Client
-	scheme *runtime.Scheme
-}
-
-// Reconcile reads that state of the cluster for a Strategy object and makes changes based on the state read
-// and what is in the Strategy.Spec
-// a Deployment as an example
-// Automatically generate RBAC rules to allow the Controller to read and write Deployments
-// +kubebuilder:rbac:groups=networking.istio.io,resources=virtualservices,verbs=get;list;watch;create;update;patch;delete
-// +kubebuilder:rbac:groups=networking.istio.io,resources=virtualservices/status,verbs=get;list;watch;create;update;patch;delete
-// +kubebuilder:rbac:groups=servicemesh.kubesphere.io,resources=strategies,verbs=get;list;watch;create;update;patch;delete
-// +kubebuilder:rbac:groups=servicemesh.kubesphere.io,resources=strategies/status,verbs=get;update;patch
-func (r *ReconcileStrategy) Reconcile(request reconcile.Request) (reconcile.Result, error) {
-
-	// Fetch the Strategy instance
-	strategy := &servicemeshv1alpha2.Strategy{}
-	err := r.Get(context.TODO(), request.NamespacedName, strategy)
-
-	if err != nil {
-		if errors.IsNotFound(err) {
-			return reconcile.Result{}, nil
-		}
-		return reconcile.Result{}, err
-	}
-
-	return r.reconcileStrategy(strategy)
-}
-
-func (r *ReconcileStrategy) reconcileStrategy(strategy *servicemeshv1alpha2.Strategy) (reconcile.Result, error) {
-
-	appName := getAppNameByStrategy(strategy)
-	service := &v1.Service{}
-
-	err := r.Get(context.TODO(), types.NamespacedName{Namespace: strategy.Namespace, Name: appName}, service)
-	if err != nil {
-		log.Error(err, "couldn't find service", "namespace", strategy.Namespace, "name", appName)
-		return reconcile.Result{}, errors.NewBadRequest(fmt.Sprintf("service %s not found", appName))
-	}
-
-	vs, err := r.generateVirtualService(strategy, service)
-
-	// Check if the VirtualService already exists
-	found := &v1alpha3.VirtualService{}
-	err = r.Get(context.TODO(), types.NamespacedName{Name: vs.Name, Namespace: vs.Namespace}, found)
-	if err != nil && errors.IsNotFound(err) {
-		log.Info("Creating VirtualService", "namespace", vs.Namespace, "name", vs.Name)
-		err = r.Create(context.TODO(), vs)
-
-		return reconcile.Result{}, err
-	} else if err != nil {
-		return reconcile.Result{}, err
-	}
-
-	// Update the found object and write the result back if there are any changes
-	if !reflect.DeepEqual(vs.Spec, found.Spec) || len(vs.OwnerReferences) == 0 {
-		found.Spec = vs.Spec
-		found.OwnerReferences = vs.OwnerReferences
-		log.Info("Updating VirtualService", "namespace", vs.Namespace, "name", vs.Name)
-		err = r.Update(context.TODO(), found)
-		if err != nil {
-			return reconcile.Result{}, err
-		}
-	}
-	return reconcile.Result{}, nil
-}
-
-func (r *ReconcileStrategy) generateVirtualService(strategy *servicemeshv1alpha2.Strategy, service *v1.Service) (*v1alpha3.VirtualService, error) {
-
-	// Define VirtualService to be created
-	vs := &v1alpha3.VirtualService{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      getAppNameByStrategy(strategy),
-			Namespace: strategy.Namespace,
-			Labels:    strategy.Spec.Selector.MatchLabels,
-		},
-		Spec: strategy.Spec.Template.Spec,
-	}
-
-	// one version rules them all
-	if len(strategy.Spec.GovernorVersion) > 0 {
-
-		governorDestinationWeight := v1alpha3.DestinationWeight{
-			Destination: v1alpha3.Destination{
-				Host:   getAppNameByStrategy(strategy),
-				Subset: strategy.Spec.GovernorVersion,
-			},
-			Weight: 100,
-		}
-
-		if len(strategy.Spec.Template.Spec.Http) > 0 {
-			governorRoute := v1alpha3.HTTPRoute{
-				Route: []v1alpha3.DestinationWeight{governorDestinationWeight},
-			}
-
-			vs.Spec.Http = []v1alpha3.HTTPRoute{governorRoute}
-		} else if len(strategy.Spec.Template.Spec.Tcp) > 0 {
-			governorRoute := v1alpha3.TCPRoute{
-				Route: []v1alpha3.DestinationWeight{governorDestinationWeight},
-			}
-			vs.Spec.Tcp = []v1alpha3.TCPRoute{governorRoute}
-		}
-
-	}
-
-	if err := fillDestinationPort(vs, service); err != nil {
-		return nil, err
-	}
-
-	return vs, nil
-}

pkg/controller/strategy/strategy_controller_test.go

-/*
-Copyright 2019 The KubeSphere authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package strategy
-
-import (
-	"github.com/knative/pkg/apis/istio/common/v1alpha1"
-	"github.com/knative/pkg/apis/istio/v1alpha3"
-	"k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/util/json"
-	"testing"
-	"time"
-
-	"github.com/onsi/gomega"
-	"golang.org/x/net/context"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
-	servicemeshv1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/manager"
-	"sigs.k8s.io/controller-runtime/pkg/reconcile"
-)
-
-var c client.Client
-
-var expectedRequest = reconcile.Request{NamespacedName: types.NamespacedName{Name: "foo", Namespace: "default"}}
-var depKey = types.NamespacedName{Name: "details", Namespace: "default"}
-
-const timeout = time.Second * 5
-
-var labels = map[string]string{
-	"app.kubernetes.io/name":            "details",
-	"app.kubernetes.io/version":         "v1",
-	"app":                               "details",
-	"servicemesh.kubesphere.io/enabled": "",
-}
-
-var svc = v1.Service{
-	ObjectMeta: metav1.ObjectMeta{
-		Name:      "details",
-		Namespace: "default",
-		Labels:    labels,
-	},
-	Spec: v1.ServiceSpec{
-		Ports: []v1.ServicePort{
-			{
-				Name:     "http",
-				Port:     8080,
-				Protocol: v1.ProtocolTCP,
-			},
-		},
-		Selector: labels,
-	},
-}
-
-func TestReconcile(t *testing.T) {
-	g := gomega.NewGomegaWithT(t)
-	instance := &servicemeshv1alpha2.Strategy{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "foo",
-			Namespace: "default",
-			Labels:    labels,
-		},
-		Spec: servicemeshv1alpha2.StrategySpec{
-			Type: servicemeshv1alpha2.CanaryType,
-			Selector: &metav1.LabelSelector{
-				MatchLabels: labels,
-			},
-			Template: servicemeshv1alpha2.VirtualServiceTemplateSpec{
-				Spec: v1alpha3.VirtualServiceSpec{
-					Hosts:    []string{"details"},
-					Gateways: []string{"default"},
-					Http: []v1alpha3.HTTPRoute{
-						{
-							Match: []v1alpha3.HTTPMatchRequest{
-								{
-									Method: &v1alpha1.StringMatch{
-										Exact: "POST",
-									},
-								},
-							},
-							Route: []v1alpha3.DestinationWeight{
-								{
-									Destination: v1alpha3.Destination{
-										Host:   "details",
-										Subset: "v1",
-									},
-									Weight: 60,
-								},
-							},
-						},
-						{
-							Route: []v1alpha3.DestinationWeight{
-								{
-									Destination: v1alpha3.Destination{
-										Host:   "details",
-										Subset: "v2",
-									},
-									Weight: 40,
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-
-	// Setup the Manager and Controller.  Wrap the Controller Reconcile function so it writes each request to a
-	// channel when it is finished.
-	mgr, err := manager.New(cfg, manager.Options{})
-	g.Expect(err).NotTo(gomega.HaveOccurred())
-	c = mgr.GetClient()
-
-	recFn, requests := SetupTestReconcile(newReconciler(mgr))
-	g.Expect(add(mgr, recFn)).NotTo(gomega.HaveOccurred())
-
-	stopMgr, mgrStopped := StartTestManager(mgr, g)
-
-	defer func() {
-		close(stopMgr)
-		mgrStopped.Wait()
-	}()
-
-	err = c.Create(context.TODO(), &svc)
-	if apierrors.IsInvalid(err) {
-		t.Logf("failed to create service, %v", err)
-		return
-	}
-	g.Expect(err).NotTo(gomega.HaveOccurred())
-	//defer c.Delete(context.TODO(), &svc)
-
-	// Create the Strategy object and expect the Reconcile and Deployment to be created
-	err = c.Create(context.TODO(), instance)
-	// The instance object may not be a valid object because it might be missing some required fields.
-	// Please modify the instance object by adding required fields and then remove the following if statement.
-	if apierrors.IsInvalid(err) {
-		t.Logf("failed to create object, got an invalid object error: %v", err)
-		return
-	}
-
-	g.Expect(err).NotTo(gomega.HaveOccurred())
-	defer c.Delete(context.TODO(), instance)
-	g.Eventually(requests, timeout).Should(gomega.Receive(gomega.Equal(expectedRequest)))
-
-	vs := &v1alpha3.VirtualService{}
-	g.Eventually(func() error { return c.Get(context.TODO(), depKey, vs) }, timeout).
-		Should(gomega.Succeed())
-
-	if str, err := json.Marshal(vs); err == nil {
-		t.Logf("Created virtual service %s\n", str)
-	}
-
-	// Delete the Deployment and expect Reconcile to be called for Deployment deletion
-	g.Expect(c.Delete(context.TODO(), vs)).NotTo(gomega.HaveOccurred())
-	//g.Eventually(requests, timeout).Should(gomega.Receive(gomega.Equal(expectedRequest)))
-	//g.Eventually(func() error { return c.Get(context.TODO(), depKey, vs) }, timeout).Should(gomega.Succeed())
-
-	// Manually delete Deployment since GC isn't enabled in the test control plane
-	g.Eventually(func() error { return c.Delete(context.TODO(), vs) }, timeout).
-		Should(gomega.MatchError("virtualservices.networking.istio.io \"details\" not found"))
-
-}

pkg/controller/virtualservice/util/util.go

 package util
 
 import (
+	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"strings"
 )
@@ -47,9 +49,9 @@ func GetComponentVersion(meta *metav1.ObjectMeta) string {
 
 func ExtractApplicationLabels(meta *metav1.ObjectMeta) map[string]string {
 
-	labels := make(map[string]string, 0)
+	labels := make(map[string]string, len(ApplicationLabels))
 	for _, label := range ApplicationLabels {
-		if len(meta.Labels[label]) == 0 {
+		if _, ok := meta.Labels[label]; !ok {
 			return nil
 		} else {
 			labels[label] = meta.Labels[label]
@@ -59,13 +61,38 @@ func ExtractApplicationLabels(meta *metav1.ObjectMeta) map[string]string {
 	return labels
 }
 
-func IsApplicationComponent(meta *metav1.ObjectMeta) bool {
+func IsApplicationComponent(lbs map[string]string) bool {
 
 	for _, label := range ApplicationLabels {
-		if len(meta.Labels[label]) == 0 {
+		if _, ok := lbs[label]; !ok {
 			return false
 		}
 	}
 
 	return true
 }
+
+// if virtualservice not specified with port number, then fill with service first port
+func FillDestinationPort(vs *v1alpha3.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)
+			}
+		}
+
+		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)
+		}
+	}
+
+	// fill tcp port
+	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)
+			}
+		}
+	}
+}

pkg/controller/virtualservice/virtualservice_controller.go

@@ -6,14 +6,17 @@ import (
 	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/types"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/kubernetes/scheme"
 	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
 	"k8s.io/kubernetes/pkg/controller"
 	"k8s.io/kubernetes/pkg/util/metrics"
 	"kubesphere.io/kubesphere/pkg/controller/virtualservice/util"
+	"reflect"
 	"strings"
 
 	logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
@@ -27,6 +30,7 @@ import (
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/client-go/util/workqueue"
+	servicemeshv1alpha2 "kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
 	servicemeshinformers "kubesphere.io/kubesphere/pkg/client/informers/externalversions/servicemesh/v1alpha2"
 	servicemeshlisters "kubesphere.io/kubesphere/pkg/client/listers/servicemesh/v1alpha2"
 
@@ -98,6 +102,7 @@ func NewVirtualServiceController(serviceInformer coreinformers.ServiceInformer,
 		AddFunc:    v.enqueueService,
 		DeleteFunc: v.enqueueService,
 		UpdateFunc: func(old, cur interface{}) {
+			// TODO(jeff): need a more robust mechanism, because user may change labels
 			v.enqueueService(cur)
 		},
 	})
@@ -109,7 +114,11 @@ func NewVirtualServiceController(serviceInformer coreinformers.ServiceInformer,
 	v.strategySynced = strategyInformer.Informer().HasSynced
 
 	strategyInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
-		DeleteFunc: v.deleteStrategy,
+		DeleteFunc: v.addStrategy,
+		AddFunc:    v.addStrategy,
+		UpdateFunc: func(old, cur interface{}) {
+			v.addStrategy(cur)
+		},
 	})
 
 	v.destinationRuleLister = destinationRuleInformer.Lister()
@@ -185,48 +194,63 @@ func (v *VirtualServiceController) processNextWorkItem() bool {
 	return true
 }
 
+// created virtualservice's name are same as the service name, same
+// as the destinationrule name
+// labels:
+//      servicemesh.kubernetes.io/enabled: ""
+//      app.kubernetes.io/name: bookinfo
+//      app: reviews
+// are used to bind them together.
+// syncService are the main part of reconcile function body, it takes
+// service, destinationrule, strategy as input to create a virtualservice
+// for service.
 func (v *VirtualServiceController) syncService(key string) error {
 	startTime := time.Now()
-	defer func() {
-		log.V(4).Info("Finished syncing service virtualservice. ", "service", key, "duration", time.Since(startTime))
-	}()
-
 	namespace, name, err := cache.SplitMetaNamespaceKey(key)
 	if err != nil {
+		log.Error(err, "not a valid controller key", "key", key)
 		return err
 	}
 
+	// default component name to service name
+	appName := name
+
+	defer func() {
+		log.V(4).Info("Finished syncing service virtualservice.", "namespace", namespace, "name", name, "duration", time.Since(startTime))
+	}()
+
 	service, err := v.serviceLister.Services(namespace).Get(name)
 	if err != nil {
-		// Delete the corresponding virtualservice, as the service has been deleted.
-		err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Delete(name, nil)
-		if err != nil && !errors.IsNotFound(err) {
-			log.Error(err, "delete orphan virtualservice failed", "namespace", service.Namespace, "name", service.Name)
-			return err
+		if errors.IsNotFound(err) {
+			// Delete the corresponding virtualservice, as the service has been deleted.
+			err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Delete(name, nil)
+			if err != nil && !errors.IsNotFound(err) {
+				log.Error(err, "delete orphan virtualservice failed", "namespace", namespace, "name", service.Name)
+				return err
+			}
+			return nil
 		}
-		return nil
+		log.Error(err, "get service failed", "namespace", namespace, "name", name)
+		return err
 	}
 
-	if len(service.Labels) < len(util.ApplicationLabels) || !util.IsApplicationComponent(&service.ObjectMeta) ||
+	if len(service.Labels) < len(util.ApplicationLabels) || !util.IsApplicationComponent(service.Labels) ||
 		len(service.Spec.Ports) == 0 {
 		// services don't have enough labels to create a virtualservice
 		// or they don't have necessary labels
 		// or they don't have any ports defined
 		return nil
 	}
-
-	vs, err := v.virtualServiceLister.VirtualServices(namespace).Get(name)
-	if err == nil {
-		// there already is virtual service there, no need to create another one
-		return nil
-	}
+	// get real component name, i.e label app value
+	appName = util.GetComponentName(&service.ObjectMeta)
 
 	destinationRule, err := v.destinationRuleLister.DestinationRules(namespace).Get(name)
 	if err != nil {
 		if errors.IsNotFound(err) {
 			// there is no destinationrule for this service
 			// maybe corresponding workloads are not created yet
-			return nil
+			log.Info("destination rules for service not found, retrying.", "namespace", namespace, "name", name)
+			return fmt.Errorf("destination rule for service %s/%s not found", namespace, name)
 		}
 		log.Error(err, "Couldn't get destinationrule for service.", "service", types.NamespacedName{Name: service.Name, Namespace: service.Namespace}.String())
 		return err
@@ -235,20 +259,49 @@ func (v *VirtualServiceController) syncService(key string) error {
 	subsets := destinationRule.Spec.Subsets
 	if len(subsets) == 0 {
 		// destination rule with no subsets, not possibly
-		err = fmt.Errorf("find destinationrule with no subsets for service %s", name)
-		log.Error(err, "Find destinationrule with no subsets for service", "namespace", service.Namespace, "name", name)
+		err = fmt.Errorf("found destinationrule with no subsets for service %s", name)
+		log.Error(err, "found destinationrule with no subsets", "namespace", namespace, "name", appName)
 		return err
-	} else {
-		vs = &v1alpha3.VirtualService{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:      name,
-				Namespace: namespace,
-				Labels:    util.ExtractApplicationLabels(&service.ObjectMeta),
-			},
-			Spec: v1alpha3.VirtualServiceSpec{
-				Hosts: []string{name},
-			},
+	}
+
+	// fetch all strategies applied to service
+	strategies, err := v.strategyLister.Strategies(namespace).List(labels.SelectorFromSet(map[string]string{util.AppLabel: appName}))
+	if err != nil {
+		log.Error(err, "list strategies for service failed", "namespace", namespace, "name", appName)
+		return err
+	} else if len(strategies) > 1 {
+		// more than one strategies are not allowed, it will cause collision
+		err = fmt.Errorf("more than one strategies applied to service %s/%s is forbbiden", namespace, appName)
+		log.Error(err, "")
+		return err
+	}
+
+	// get current virtual service
+	currentVirtualService, err := v.virtualServiceLister.VirtualServices(namespace).Get(appName)
+	if err != nil {
+		if errors.IsNotFound(err) {
+			currentVirtualService = &v1alpha3.VirtualService{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      appName,
+					Namespace: namespace,
+					Labels:    util.ExtractApplicationLabels(&service.ObjectMeta),
+				},
+			}
+		} else {
+			log.Error(err, "cannot get virtualservice ", "namespace", namespace, "name", appName)
+			return err
 		}
+	}
+	vs := currentVirtualService.DeepCopy()
+
+	if len(strategies) > 0 {
+		// apply strategy spec to virtualservice
+		vs.Spec = v.generateVirtualServiceSpec(strategies[0], service).Spec
+	} else {
+		// create a whole new virtualservice
+
+		// TODO(jeff): use FQDN to replace service name
+		vs.Spec.Hosts = []string{name}
 
 		// check if service has TCP protocol ports
 		for _, port := range service.Spec.Ports {
@@ -275,18 +328,45 @@ func (v *VirtualServiceController) syncService(key string) error {
 				vs.Spec.Tcp = []v1alpha3.TCPRoute{{Route: []v1alpha3.DestinationWeight{route}}}
 			}
 		}
+	}
 
-		if len(vs.Spec.Http) > 0 || len(vs.Spec.Tcp) > 0 {
-			_, err := v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Create(vs)
-			if err != nil {
-				v.eventRecorder.Event(vs, v1.EventTypeWarning, "FailedToCreateVirtualService", fmt.Sprintf("Failed to create virtualservice for service %v/%v: %v", service.Namespace, service.Name, err))
-				log.Error(err, "create virtualservice for service failed.", "service", service)
-				return err
-			}
+	createVirtualService := len(currentVirtualService.ResourceVersion) == 0
+
+	if !createVirtualService &&
+		reflect.DeepEqual(vs.Spec, currentVirtualService.Spec) &&
+		reflect.DeepEqual(service.Labels, currentVirtualService.Labels) {
+		log.V(4).Info("virtual service are equal, skipping update ")
+		return nil
+	}
+
+	newVirtualService := currentVirtualService.DeepCopy()
+	newVirtualService.Labels = service.Labels
+	newVirtualService.Spec = vs.Spec
+	if newVirtualService.Annotations == nil {
+		newVirtualService.Annotations = make(map[string]string)
+	}
+
+	if len(newVirtualService.Spec.Http) == 0 && len(newVirtualService.Spec.Tcp) == 0 && len(newVirtualService.Spec.Tls) == 0 {
+		err = fmt.Errorf("service %s/%s doesn't have a valid port spec", namespace, name)
+		log.Error(err, "")
+		return err
+	}
+
+	if createVirtualService {
+		_, err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Create(newVirtualService)
+	} else {
+		_, err = v.virtualServiceClient.NetworkingV1alpha3().VirtualServices(namespace).Update(newVirtualService)
+	}
+
+	if err != nil {
+
+		if createVirtualService {
+			v.eventRecorder.Event(newVirtualService, v1.EventTypeWarning, "FailedToCreateVirtualService", fmt.Sprintf("Failed to create virtualservice for service %v/%v: %v", namespace, name, err))
 		} else {
-			log.Info("service doesn't have a tcp port.")
-			return nil
+			v.eventRecorder.Event(newVirtualService, v1.EventTypeWarning, "FailedToUpdateVirtualService", fmt.Sprintf("Failed to update virtualservice for service %v/%v: %v", namespace, name, err))
 		}
+
+		return err
 	}
 
 	return nil
@@ -299,7 +379,7 @@ func (v *VirtualServiceController) addDestinationRule(obj interface{}) {
 	service, err := v.serviceLister.Services(dr.Namespace).Get(dr.Name)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			log.V(0).Info("service not created yet", "namespace", dr.Namespace, "service", dr.Name)
+			log.V(3).Info("service not created yet", "namespace", dr.Namespace, "service", dr.Name)
 			return
 		}
 		utilruntime.HandleError(fmt.Errorf("unable to get service with name %s/%s", dr.Namespace, dr.Name))
@@ -324,8 +404,46 @@ func (v *VirtualServiceController) addDestinationRule(obj interface{}) {
 	return
 }
 
-func (v *VirtualServiceController) deleteStrategy(obj interface{}) {
-	// nothing to do right now
+// when a strategy created
+func (v *VirtualServiceController) addStrategy(obj interface{}) {
+	strategy := obj.(*servicemeshv1alpha2.Strategy)
+
+	lbs := util.ExtractApplicationLabels(&strategy.ObjectMeta)
+	if len(lbs) == 0 {
+		err := fmt.Errorf("invalid strategy %s/%s labels %s, not have required labels", strategy.Namespace, strategy.Name, strategy.Labels)
+		log.Error(err, "")
+		utilruntime.HandleError(err)
+		return
+	}
+
+	allServices, err := v.serviceLister.Services(strategy.Namespace).List(labels.SelectorFromSet(lbs))
+	if err != nil {
+		log.Error(err, "list services failed")
+		utilruntime.HandleError(err)
+		return
+	}
+
+	// avoid insert a key multiple times
+	set := sets.String{}
+
+	for i := range allServices {
+		service := allServices[i]
+		if service.Spec.Selector == nil || len(service.Spec.Ports) == 0 {
+			// services with nil selectors match nothing, not everything.
+			continue
+		}
+
+		key, err := controller.KeyFunc(service)
+		if err != nil {
+			utilruntime.HandleError(err)
+			return
+		}
+		set.Insert(key)
+	}
+
+	for key := range set {
+		v.queue.Add(key)
+	}
 }
 
 func (v *VirtualServiceController) handleErr(err error, key interface{}) {
@@ -344,3 +462,40 @@ func (v *VirtualServiceController) handleErr(err error, key interface{}) {
 	v.queue.Forget(key)
 	utilruntime.HandleError(err)
 }
+
+func (v *VirtualServiceController) generateVirtualServiceSpec(strategy *servicemeshv1alpha2.Strategy, service *v1.Service) *v1alpha3.VirtualService {
+
+	// Define VirtualService to be created
+	vs := &v1alpha3.VirtualService{
+		Spec: strategy.Spec.Template.Spec,
+	}
+
+	// one version rules them all
+	if len(strategy.Spec.GovernorVersion) > 0 {
+
+		governorDestinationWeight := v1alpha3.DestinationWeight{
+			Destination: v1alpha3.Destination{
+				Host:   service.Name,
+				Subset: strategy.Spec.GovernorVersion,
+			},
+			Weight: 100,
+		}
+
+		if len(strategy.Spec.Template.Spec.Http) > 0 {
+			governorRoute := v1alpha3.HTTPRoute{
+				Route: []v1alpha3.DestinationWeight{governorDestinationWeight},
+			}
+
+			vs.Spec.Http = []v1alpha3.HTTPRoute{governorRoute}
+		} else if len(strategy.Spec.Template.Spec.Tcp) > 0 {
+			governorRoute := v1alpha3.TCPRoute{
+				Route: []v1alpha3.DestinationWeight{governorDestinationWeight},
+			}
+			vs.Spec.Tcp = []v1alpha3.TCPRoute{governorRoute}
+		}
+
+	}
+
+	util.FillDestinationPort(vs, service)
+	return vs
+}

pkg/models/resources/s2irun.go

@@ -41,6 +41,10 @@ func (*s2iRunSearcher) match(match map[string]string, item *v1alpha1.S2iRun) boo
 			if item.Name != v && item.Labels[displayName] != v {
 				return false
 			}
+		case status:
+			if string(item.Status.RunState) != v{
+				return false
+			}
 		default:
 			return false
 		}

pkg/simple/client/k8s/k8sclient.go

@@ -34,12 +34,12 @@ var (
 	k8sClient      *kubernetes.Clientset
 	k8sClientOnce  sync.Once
 	KubeConfig     *rest.Config
-	masterURL       string
+	masterURL      string
 )
 
 func init() {
 	flag.StringVar(&kubeConfigFile, "kubeconfig", "", "path to kubeconfig file")
-	flag.StringVar(&masterURL, "master-url","", "kube-apiserver url, only needed when out of cluster")
+	flag.StringVar(&masterURL, "master-url", "", "kube-apiserver url, only needed when out of cluster")
 }
 
 func Client() *kubernetes.Clientset {

vendor/github.com/kiali/kiali/models/destination_rule.go

@@ -79,16 +79,17 @@ func (dRule *DestinationRule) HasCircuitBreaker(namespace string, serviceName st
 	return false
 }
 
+// change circuit breaker to true only connectionPool and outlierDetection
+// are both set
 func isCircuitBreakerTrafficPolicy(trafficPolicy interface{}) bool {
 	if trafficPolicy == nil {
 		return false
 	}
 	if dTrafficPolicy, ok := trafficPolicy.(map[string]interface{}); ok {
 		if _, ok := dTrafficPolicy["connectionPool"]; ok {
-			return true
-		}
-		if _, ok := dTrafficPolicy["outlierDetection"]; ok {
-			return true
+			if _, ok := dTrafficPolicy["outlierDetection"]; ok {
+				return true
+			}
 		}
 	}
 	return false