add service mesh controller

add service mesh metrics

remove unused circle yaml

fix travis misconfiguration

fix travis misconfiguration

fix travis misconfiguration

pkg/apis/addtoscheme_servicemesh_v1alpha2.go

@@ -0,0 +1,35 @@
+/*
+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 apis
+
+import (
+	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"kubesphere.io/kubesphere/pkg/apis/servicemesh/v1alpha2"
+
+	"sigs.k8s.io/application/pkg/apis/app/v1beta1"
+)
+
+func init() {
+	// Register the types with the Scheme so the components can map objects to GroupVersionKinds and back
+	AddToSchemes = append(AddToSchemes, v1alpha2.SchemeBuilder.AddToScheme)
+
+	// Register networking.istio.io/v1alpha3
+	AddToSchemes = append(AddToSchemes, v1alpha3.SchemeBuilder.AddToScheme)
+
+	// Register application scheme
+	AddToSchemes = append(AddToSchemes, v1beta1.SchemeBuilder.AddToScheme)
+}

pkg/apis/servicemesh/group.go

@@ -0,0 +1,18 @@
+/*
+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 servicemesh contains servicemesh API versions
+package servicemesh

pkg/apis/servicemesh/metrics/install/install.go

@@ -0,0 +1,16 @@
+package install
+
+import (
+	"github.com/emicklei/go-restful"
+	urlruntime "k8s.io/apimachinery/pkg/util/runtime"
+	"kubesphere.io/kubesphere/pkg/apis/servicemesh/metrics/v1alpha2"
+	"kubesphere.io/kubesphere/pkg/apiserver/runtime"
+)
+
+func init() {
+	Install(runtime.Container)
+}
+
+func Install(c *restful.Container) {
+	urlruntime.Must(v1alpha2.AddToContainer(c))
+}

pkg/apis/servicemesh/metrics/v1alpha2/register.go

@@ -0,0 +1,132 @@
+package v1alpha2
+
+import (
+	"github.com/emicklei/go-restful"
+	"github.com/emicklei/go-restful-openapi"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"kubesphere.io/kubesphere/pkg/apiserver/runtime"
+	"kubesphere.io/kubesphere/pkg/apiserver/servicemesh/metrics"
+	"kubesphere.io/kubesphere/pkg/errors"
+)
+
+const GroupName = "servicemesh.kubesphere.io"
+
+var GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha2"}
+
+var (
+	WebServiceBuilder = runtime.NewContainerBuilder(addWebService)
+	AddToContainer    = WebServiceBuilder.AddToContainer
+)
+
+func addWebService(c *restful.Container) error {
+
+	tags := []string{"ServiceMesh"}
+
+	webservice := runtime.NewWebService(GroupVersion)
+
+	// Get service metrics
+	// GET /namespaces/{namespace}/services/{service}/metrics
+	webservice.Route(webservice.GET("/namespaces/{namespace}/services/{service}/metrics").
+		To(metrics.GetServiceMetrics).
+		Metadata(restfulspec.KeyOpenAPITags, tags).
+		Doc("Get app metrics from a specific namespace").
+		Param(webservice.PathParameter("namespace", "name of the namespace")).
+		Param(webservice.PathParameter("service", "name of the service")).
+		Param(webservice.QueryParameter("filters[]", "type of metrics type, e.g. request_count, request_duration, request_error_count")).
+		Param(webservice.QueryParameter("queryTime", "from which UNIX time to extract metrics")).
+		Param(webservice.QueryParameter("duration", "metrics duration, in seconds")).
+		Param(webservice.QueryParameter("step", "metrics step")).
+		Param(webservice.QueryParameter("rateInterval", "metrics rate intervals, e.g. 20s")).
+		Param(webservice.QueryParameter("quantiles[]", "metrics quantiles, 0.5, 0.9, 0.99")).
+		Param(webservice.QueryParameter("byLabels[]", "by which labels to group node, e.g. source_workload, destination_service_name")).
+		Param(webservice.QueryParameter("requestProtocol", "request protocol, http/tcp")).
+		Param(webservice.QueryParameter("reporter", "destination")).
+		Writes(errors.Error{})).Produces(restful.MIME_JSON)
+
+	// Get app metrics
+	// Get /namespaces/{namespace}/apps/{app}/metrics
+	webservice.Route(webservice.GET("/namespaces/{namespace}/apps/{app}/metrics").
+		To(metrics.GetAppMetrics).
+		Metadata(restfulspec.KeyOpenAPITags, tags).
+		Doc("Get app metrics from a specific namespace").
+		Param(webservice.PathParameter("namespace", "name of the namespace")).
+		Param(webservice.PathParameter("app", "name of the workload label app value")).
+		Param(webservice.QueryParameter("filters[]", "type of metrics type, e.g. request_count, request_duration, request_error_count")).
+		Param(webservice.QueryParameter("queryTime", "from which UNIX time to extract metrics")).
+		Param(webservice.QueryParameter("duration", "metrics duration, in seconds")).
+		Param(webservice.QueryParameter("step", "metrics step")).
+		Param(webservice.QueryParameter("rateInterval", "metrics rate intervals, e.g. 20s")).
+		Param(webservice.QueryParameter("quantiles[]", "metrics quantiles, 0.5, 0.9, 0.99")).
+		Param(webservice.QueryParameter("byLabels[]", "by which labels to group node, e.g. source_workload, destination_service_name")).
+		Param(webservice.QueryParameter("requestProtocol", "request protocol, http/tcp")).
+		Param(webservice.QueryParameter("reporter", "destination")).
+		Writes(errors.Error{})).Produces(restful.MIME_JSON)
+
+	// Get workload metrics
+	// Get /namespaces/{namespace}/workloads/{workload}/metrics
+	webservice.Route(webservice.GET("/namespaces/{namespace}/workloads/{workload}/metrics").
+		To(metrics.GetWorkloadMetrics).
+		Metadata(restfulspec.KeyOpenAPITags, tags).
+		Doc("Get workload metrics from a specific namespace").
+		Param(webservice.PathParameter("namespace", "name of the namespace")).
+		Param(webservice.PathParameter("workload", "name of the workload")).
+		Param(webservice.QueryParameter("filters[]", "type of metrics type, e.g. request_count, request_duration, request_error_count")).
+		Param(webservice.QueryParameter("queryTime", "from which UNIX time to extract metrics")).
+		Param(webservice.QueryParameter("duration", "metrics duration, in seconds")).
+		Param(webservice.QueryParameter("step", "metrics step")).
+		Param(webservice.QueryParameter("rateInterval", "metrics rate intervals, e.g. 20s")).
+		Param(webservice.QueryParameter("quantiles[]", "metrics quantiles, 0.5, 0.9, 0.99")).
+		Param(webservice.QueryParameter("byLabels[]", "by which labels to group node, e.g. source_workload, destination_service_name")).
+		Param(webservice.QueryParameter("requestProtocol", "request protocol, http/tcp")).
+		Param(webservice.QueryParameter("reporter", "destination")).
+		Writes(errors.Error{})).Produces(restful.MIME_JSON)
+
+	// Get namespace metrics
+	// Get /namespaces/{namespace}/metrics
+	webservice.Route(webservice.GET("/namespaces/{namespace}/metrics").
+		To(metrics.GetNamespaceMetrics).
+		Metadata(restfulspec.KeyOpenAPITags, tags).
+		Doc("Get workload metrics from a specific namespace").
+		Param(webservice.PathParameter("namespace", "name of the namespace")).
+		Param(webservice.QueryParameter("filters[]", "type of metrics type, e.g. request_count, request_duration, request_error_count")).
+		Param(webservice.QueryParameter("queryTime", "from which UNIX time to extract metrics")).
+		Param(webservice.QueryParameter("duration", "metrics duration, in seconds")).
+		Param(webservice.QueryParameter("step", "metrics step")).
+		Param(webservice.QueryParameter("rateInterval", "metrics rate intervals, e.g. 20s")).
+		Param(webservice.QueryParameter("quantiles[]", "metrics quantiles, 0.5, 0.9, 0.99")).
+		Param(webservice.QueryParameter("byLabels[]", "by which labels to group node, e.g. source_workload, destination_service_name")).
+		Param(webservice.QueryParameter("requestProtocol", "request protocol, http/tcp")).
+		Param(webservice.QueryParameter("reporter", "destination")).
+		Writes(errors.Error{})).Produces(restful.MIME_JSON)
+
+	// Get namespace graph
+	// Get /namespaces/{namespace}/graph
+	webservice.Route(webservice.GET("/namespaces/{namespace}/graph").
+		To(metrics.GetNamespaceGraph).
+		Metadata(restfulspec.KeyOpenAPITags, tags).
+		Doc("Get service graph for a specific namespace").
+		Param(webservice.PathParameter("namespace", "name of a namespace")).
+		Param(webservice.QueryParameter("graphType", "type of the generated service graph, eg. ")).
+		Param(webservice.QueryParameter("groupBy", "group nodes by kind")).
+		Param(webservice.QueryParameter("queryTime", "from which time point, default now")).
+		Param(webservice.QueryParameter("injectServiceNodes", "whether to inject service ndoes")).
+		Writes(errors.Error{})).Produces(restful.MIME_JSON)
+
+	// Get namespaces graph, for multiple namespaces
+	// Get /namespaces/graph
+	webservice.Route(webservice.GET("/namespaces/{namespace}/graph").
+		To(metrics.GetNamespacesGraph).
+		Metadata(restfulspec.KeyOpenAPITags, tags).
+		Doc("Get service graph for a specific namespace").
+		Param(webservice.PathParameter("namespace", "name of a namespace")).
+		Param(webservice.QueryParameter("graphType", "type of the generated service graph, eg. ")).
+		Param(webservice.QueryParameter("groupBy", "group nodes by kind")).
+		Param(webservice.QueryParameter("queryTime", "from which time point, default now")).
+		Param(webservice.QueryParameter("injectServiceNodes", "whether to inject service ndoes")).
+		Param(webservice.QueryParameter("namespaces", "names of namespaces")).
+		Writes(errors.Error{})).Produces(restful.MIME_JSON)
+
+	c.Add(webservice)
+
+	return nil
+}

pkg/apis/servicemesh/v1alpha2/doc.go

@@ -0,0 +1,23 @@
+/*
+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 contains API Schema definitions for the servicemesh v1alpha2 API group
+// +k8s:openapi-gen=true
+// +k8s:deepcopy-gen=package,register
+// +k8s:conversion-gen=kubesphere.io/kubesphere/pkg/apis/servicemesh
+// +k8s:defaulter-gen=TypeMeta
+// +groupName=servicemesh.kubesphere.io
+package v1alpha2

pkg/apis/servicemesh/v1alpha2/register.go

@@ -0,0 +1,46 @@
+/*
+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.
+*/
+
+// NOTE: Boilerplate only.  Ignore this file.
+
+// Package v1alpha2 contains API Schema definitions for the servicemesh v1alpha2 API group
+// +k8s:openapi-gen=true
+// +k8s:deepcopy-gen=package,register
+// +k8s:conversion-gen=kubesphere.io/kubesphere/pkg/apis/servicemesh
+// +k8s:defaulter-gen=TypeMeta
+// +groupName=servicemesh.kubesphere.io
+package v1alpha2
+
+import (
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"sigs.k8s.io/controller-runtime/pkg/runtime/scheme"
+)
+
+var (
+	// SchemeGroupVersion is group version used to register these objects
+	SchemeGroupVersion = schema.GroupVersion{Group: "servicemesh.kubesphere.io", Version: "v1alpha2"}
+
+	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
+	SchemeBuilder = &scheme.Builder{GroupVersion: SchemeGroupVersion}
+
+	// AddToScheme is required by pkg/client/...
+	AddToScheme = SchemeBuilder.AddToScheme
+)
+
+// Resource is required by pkg/client/listers/...
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}

pkg/apis/servicemesh/v1alpha2/strategy_types.go

@@ -0,0 +1,151 @@
+/*
+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.
+
+type StrategyType string
+
+const (
+
+	// Canary strategy type
+	CanaryType StrategyType = "Canary"
+
+	// BlueGreen strategy type
+	BlueGreenType StrategyType = "BlueGreen"
+
+	// Mirror strategy type
+	Mirror StrategyType = "Mirror"
+)
+
+// StrategySpec defines the desired state of Strategy
+type StrategySpec struct {
+
+	// Strategy type
+	Type StrategyType `json:"type,omitempty"`
+
+	// Label selector for virtual services.
+	// +optional
+	Selector *metav1.LabelSelector `json:"selector,omitempty"`
+
+	// Template describes the virtual service that will be created.
+	Template VirtualServiceTemplateSpec `json:"template,omitempty"`
+
+	// Indicates that the strategy is paused and will not be processed
+	// by the strategy controller
+	Paused bool `json:"paused,omitempty"`
+}
+
+// VirtualServiceTemplateSpec
+type VirtualServiceTemplateSpec struct {
+
+	// Metadata of the virtual services created from this template
+	// +optional
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	// Spec indicates the behavior of a virtual service.
+	// +optional
+	Spec v1alpha3.VirtualServiceSpec `json:"spec,omitempty"`
+}
+
+// StrategyStatus defines the observed state of Strategy
+type StrategyStatus struct {
+	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
+	// Important: Run "make" to regenerate code after modifying this file
+
+	// The latest available observations of an object's current state.
+	// +optional
+	Conditions []StrategyCondition
+
+	// 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
+}
+
+type StrategyConditionType string
+
+// These are valid conditions of a strategy.
+const (
+	// StrategyComplete means the strategy has been delivered to istio.
+	StrategyComplete StrategyConditionType = "Complete"
+
+	// StrategyFailed means the strategy has failed its delivery to istio.
+	StrategyFailed StrategyConditionType = "Failed"
+)
+
+// StrategyCondition describes current state of a strategy.
+type StrategyCondition struct {
+	// Type of strategy condition, Complete or Failed.
+	Type StrategyConditionType
+
+	// 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
+}
+
+// +genclient
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// Strategy is the Schema for the strategies API
+// +k8s:openapi-gen=true
+type Strategy struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   StrategySpec   `json:"spec,omitempty"`
+	Status StrategyStatus `json:"status,omitempty"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// StrategyList contains a list of Strategy
+type StrategyList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Strategy `json:"items"`
+}
+
+func init() {
+	SchemeBuilder.Register(&Strategy{}, &StrategyList{})
+}

pkg/apis/servicemesh/v1alpha2/strategy_types_test.go

@@ -0,0 +1,88 @@
+/*
+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"
+	"io/ioutil"
+	"k8s.io/apimachinery/pkg/util/json"
+	"k8s.io/client-go/kubernetes/scheme"
+	"testing"
+
+	"github.com/onsi/gomega"
+	"golang.org/x/net/context"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+func TestStorageStrategy(t *testing.T) {
+	key := types.NamespacedName{
+		Name:      "foo",
+		Namespace: "default",
+	}
+	created := &Strategy{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo",
+			Namespace: "default",
+		},
+		Spec: StrategySpec{
+			Template: VirtualServiceTemplateSpec{
+				Spec: v1alpha3.VirtualServiceSpec{
+					Hosts: []string{
+						"details",
+					},
+				},
+			},
+		},
+	}
+	g := gomega.NewGomegaWithT(t)
+
+	// Test Create
+	fetched := &Strategy{}
+	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())
+}
+
+func TestStrategyRead(t *testing.T) {
+
+	//g := gomega.NewGomegaWithT(t)
+
+	var str []byte
+	file, err := ioutil.ReadFile("/Users/zry/go/src/kubesphere.io/kubesphere/config/samples/servicemesh_v1alpha2_strategy.yaml")
+	if err == nil {
+		obj, _, _ := scheme.Codecs.UniversalDeserializer().Decode(file, nil, &Strategy{})
+		switch obj.(type) {
+		case *Strategy:
+			str, err = json.Marshal(obj)
+			t.Logf("Read strategy %s", str)
+		}
+	}
+}

pkg/apis/servicemesh/v1alpha2/v1alpha2_suite_test.go

@@ -0,0 +1,55 @@
+/*
+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 (
+	"log"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/rest"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/envtest"
+)
+
+var cfg *rest.Config
+var c client.Client
+
+func TestMain(m *testing.M) {
+	t := &envtest.Environment{
+		CRDDirectoryPaths: []string{filepath.Join("..", "..", "..", "..", "config", "crds")},
+	}
+
+	err := SchemeBuilder.AddToScheme(scheme.Scheme)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if cfg, err = t.Start(); err != nil {
+		log.Fatal(err)
+	}
+
+	if c, err = client.New(cfg, client.Options{Scheme: scheme.Scheme}); err != nil {
+		log.Fatal(err)
+	}
+
+	code := m.Run()
+	t.Stop()
+	os.Exit(code)
+}

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

@@ -0,0 +1,176 @@
+// +build !ignore_autogenerated
+
+/*
+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 deepcopy-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	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 *Strategy) DeepCopyInto(out *Strategy) {
+	*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 Strategy.
+func (in *Strategy) DeepCopy() *Strategy {
+	if in == nil {
+		return nil
+	}
+	out := new(Strategy)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Strategy) 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 *StrategyCondition) DeepCopyInto(out *StrategyCondition) {
+	*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 StrategyCondition.
+func (in *StrategyCondition) DeepCopy() *StrategyCondition {
+	if in == nil {
+		return nil
+	}
+	out := new(StrategyCondition)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *StrategyList) DeepCopyInto(out *StrategyList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]Strategy, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StrategyList.
+func (in *StrategyList) DeepCopy() *StrategyList {
+	if in == nil {
+		return nil
+	}
+	out := new(StrategyList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *StrategyList) 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 *StrategySpec) DeepCopyInto(out *StrategySpec) {
+	*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 StrategySpec.
+func (in *StrategySpec) DeepCopy() *StrategySpec {
+	if in == nil {
+		return nil
+	}
+	out := new(StrategySpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *StrategyStatus) DeepCopyInto(out *StrategyStatus) {
+	*out = *in
+	if in.Conditions != nil {
+		in, out := &in.Conditions, &out.Conditions
+		*out = make([]StrategyCondition, 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 StrategyStatus.
+func (in *StrategyStatus) DeepCopy() *StrategyStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(StrategyStatus)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *VirtualServiceTemplateSpec) DeepCopyInto(out *VirtualServiceTemplateSpec) {
+	*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 VirtualServiceTemplateSpec.
+func (in *VirtualServiceTemplateSpec) DeepCopy() *VirtualServiceTemplateSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(VirtualServiceTemplateSpec)
+	in.DeepCopyInto(out)
+	return out
+}

pkg/apiserver/servicemesh/metrics/handlers.go

@@ -0,0 +1,43 @@
+package metrics
+
+import (
+	"fmt"
+	"github.com/emicklei/go-restful"
+	"github.com/kiali/kiali/handlers"
+)
+
+// Get app metrics
+func GetAppMetrics(request *restful.Request, response *restful.Response) {
+	handlers.AppMetrics(response.ResponseWriter, request.Request)
+}
+
+// Get workload metrics
+func GetWorkloadMetrics(request *restful.Request, response *restful.Response) {
+	handlers.WorkloadMetrics(response.ResponseWriter, request.Request)
+}
+
+// Get service metrics
+func GetServiceMetrics(request *restful.Request, response *restful.Response) {
+	handlers.ServiceMetrics(response.ResponseWriter, request.Request)
+}
+
+// Get namespace metrics
+func GetNamespaceMetrics(request *restful.Request, response *restful.Response) {
+	handlers.NamespaceMetrics(response.ResponseWriter, request.Request)
+}
+
+// Get service graph for namespace
+func GetNamespaceGraph(request *restful.Request, response *restful.Response) {
+	namespace := request.PathParameter("namespace")
+
+	if len(namespace) > 0 {
+		request.Request.URL.RawQuery = fmt.Sprintf("%s&namespaces=%s", request.Request.URL.RawQuery, namespace)
+	}
+
+	handlers.GraphNamespaces(response.ResponseWriter, request.Request)
+}
+
+// Get service graph for namespaces
+func GetNamespacesGraph(request *restful.Request, response *restful.Response) {
+	handlers.GraphNamespaces(response.ResponseWriter, request.Request)
+}

pkg/controller/add_strategy.go

@@ -0,0 +1,30 @@
+/*
+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 controller
+
+import (
+	"kubesphere.io/kubesphere/pkg/controller/strategy"
+)
+
+func init() {
+	// AddToManagerFuncs is a list of functions to create controllers and add them to a manager.
+	AddToManagerFuncs = append(AddToManagerFuncs, strategy.Add)
+
+	// Add application to manager functions
+	//AddToManagerFuncs = append(AddToManagerFuncs, application.Add)
+
+}

pkg/controller/controller.go

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 The KubeSphere authors.
+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.

pkg/controller/strategy/strategy_controller.go

@@ -0,0 +1,148 @@
+/*
+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"
+	"github.com/knative/pkg/apis/istio/v1alpha3"
+	"reflect"
+
+	"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"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+	"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("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
+	}
+	err = c.Watch(&source.Kind{Type: &v1alpha3.VirtualService{}}, &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) {
+			// Object not found, return.  Created objects are automatically garbage collected.
+			// For additional cleanup logic use finalizers.
+			return reconcile.Result{}, nil
+		}
+		// Error reading the object - requeue the request.
+		return reconcile.Result{}, err
+	}
+
+	// Define VirtualService to be created
+	vs := &v1alpha3.VirtualService{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      strategy.Name + "-virtualservice",
+			Namespace: strategy.Namespace,
+			Labels:    strategy.Spec.Selector.MatchLabels,
+		},
+		Spec: strategy.Spec.Template.Spec,
+	}
+
+	if err := controllerutil.SetControllerReference(strategy, vs, r.scheme); err != nil {
+		return reconcile.Result{}, err
+	}
+
+	// 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) {
+		found.Spec = vs.Spec
+		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
+}

pkg/controller/strategy/strategy_controller_suite_test.go

@@ -0,0 +1,75 @@
+/*
+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 (
+	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"
+)
+
+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)
+	}
+
+	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
+}

pkg/controller/strategy/strategy_controller_test.go

@@ -0,0 +1,143 @@
+/*
+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/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: "foo-virtualservice", Namespace: "default"}
+
+const timeout = time.Second * 5
+
+func TestReconcile(t *testing.T) {
+	g := gomega.NewGomegaWithT(t)
+	instance := &servicemeshv1alpha2.Strategy{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "foo",
+			Namespace: "default",
+		},
+		Spec: servicemeshv1alpha2.StrategySpec{
+			Type: servicemeshv1alpha2.CanaryType,
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{
+					"type": "Canary",
+				},
+			},
+			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()
+	}()
+
+	// 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 \"foo-virtualservice\" not found"))
+
+}

pkg/models/servicemesh/metrics/handlers.go

@@ -0,0 +1,7 @@
+package metrics
+
+import "github.com/emicklei/go-restful"
+
+func GetAppMetrics(request *restful.Request, response *restful.Response) {
+
+}

pkg/options/options.go

@@ -17,11 +17,7 @@
 */
 package options
 
-import (
-	"github.com/spf13/pflag"
-)
-
-var SharedOptions = NewServerRunOptions()
+import "github.com/spf13/pflag"
 
 type ServerRunOptions struct {
 	// server bind address
@@ -38,8 +34,6 @@ type ServerRunOptions struct {
 
 	// tls private key file
 	TlsPrivateKey string
-
-	CommandLine *pflag.FlagSet
 }
 
 func NewServerRunOptions() *ServerRunOptions {
@@ -50,14 +44,16 @@ func NewServerRunOptions() *ServerRunOptions {
 		SecurePort:    0,
 		TlsCertFile:   "",
 		TlsPrivateKey: "",
-		CommandLine:   &pflag.FlagSet{},
 	}
 
-	s.CommandLine.StringVar(&s.BindAddress, "bind-address", "0.0.0.0", "server bind address")
-	s.CommandLine.IntVar(&s.InsecurePort, "insecure-port", 9090, "insecure port number")
-	s.CommandLine.IntVar(&s.SecurePort, "secure-port", 0, "secure port number")
-	s.CommandLine.StringVar(&s.TlsCertFile, "tls-cert-file", "", "tls cert file")
-	s.CommandLine.StringVar(&s.TlsPrivateKey, "tls-private-key", "", "tls private key")
-
 	return &s
 }
+
+func (s *ServerRunOptions) AddFlags(fs *pflag.FlagSet) {
+
+	fs.StringVar(&s.BindAddress, "bind-address", "0.0.0.0", "server bind address")
+	fs.IntVar(&s.InsecurePort, "insecure-port", 9090, "insecure port number")
+	fs.IntVar(&s.SecurePort, "secure-port", 0, "secure port number")
+	fs.StringVar(&s.TlsCertFile, "tls-cert-file", "", "tls cert file")
+	fs.StringVar(&s.TlsPrivateKey, "tls-private-key", "", "tls private key")
+}

pkg/simple/client/prometheus/prometheusclient.go

@@ -38,11 +38,11 @@ const (
 )
 
 var (
-	prometheusAPIEndpoint string
+	PrometheusAPIEndpoint string
 )
 
 func init() {
-	flag.StringVar(&prometheusAPIEndpoint, "prometheus-endpoint", "http://prometheus-k8s.kubesphere-monitoring-system.svc:9090/api/v1/", "prometheus api endpoint")
+	flag.StringVar(&PrometheusAPIEndpoint, "prometheus-endpoint", "http://prometheus-k8s.kubesphere-monitoring-system.svc:9090/api/v1/", "prometheus api endpoint")
 }
 
 type MonitoringRequestParams struct {
@@ -71,7 +71,7 @@ type MonitoringRequestParams struct {
 }
 
 func SendMonitoringRequest(queryType string, params string) string {
-	epurl := prometheusAPIEndpoint + queryType + params
+	epurl := PrometheusAPIEndpoint + queryType + params
 
 	response, err := http.DefaultClient.Get(epurl)
 	if err != nil {

pkg/utils/utils.go

@@ -0,0 +1,7 @@
+package utils
+
+func CheckError(err error) {
+	if err != nil {
+		panic(err)
+	}
+}