clean old devops code

todo impl use informer

Signed-off-by: runzexia <runzexia@yunify.com>

pkg/kapis/monitoring/v1alpha2/handler.go

@@ -1,145 +0,0 @@
-/*
-
- 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/emicklei/go-restful"
-	"kubesphere.io/kubesphere/pkg/api"
-	"kubesphere.io/kubesphere/pkg/api/monitoring/v1alpha2"
-	model "kubesphere.io/kubesphere/pkg/models/monitoring"
-	"kubesphere.io/kubesphere/pkg/simple/client/k8s"
-	"kubesphere.io/kubesphere/pkg/simple/client/monitoring"
-)
-
-type handler struct {
-	k  k8s.Client
-	mo model.MonitoringOperator
-}
-
-func newHandler(k k8s.Client, m monitoring.Interface) *handler {
-	return &handler{k, model.NewMonitoringOperator(m)}
-}
-
-func (h handler) handleClusterMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelCluster)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handleNodeMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelNode)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handleWorkspaceMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelWorkspace)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handleNamespaceMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelNamespace)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handleWorkloadMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelWorkload)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handlePodMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelPod)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handleContainerMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelContainer)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handlePVCMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelPVC)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handleComponentMetricsQuery(req *restful.Request, resp *restful.Response) {
-	p, err := h.parseRequestParams(req, monitoring.LevelComponent)
-	if err != nil {
-		api.HandleBadRequest(resp, nil, err)
-		return
-	}
-	h.handleNamedMetricsQuery(resp, p)
-}
-
-func (h handler) handleNamedMetricsQuery(resp *restful.Response, p params) {
-	var res v1alpha2.APIResponse
-	var err error
-
-	if p.isRangeQuery() {
-		res, err = h.mo.GetNamedMetricsOverTime(p.start, p.end, p.step, p.option)
-		if err != nil {
-			api.HandleInternalError(resp, nil, err)
-			return
-		}
-	} else {
-		res, err = h.mo.GetNamedMetrics(p.time, p.option)
-		if err != nil {
-			api.HandleInternalError(resp, nil, err)
-			return
-		}
-
-		if p.shouldSort() {
-			var rows int
-			res, rows = h.mo.SortMetrics(res, p.target, p.order, p.identifier)
-			res = h.mo.PageMetrics(res, p.page, p.limit, rows)
-		}
-	}
-
-	resp.WriteAsJson(res)
-}

pkg/kapis/monitoring/v1alpha2/helper.go

@@ -1,217 +0,0 @@
-package v1alpha2
-
-import (
-	"fmt"
-	"github.com/emicklei/go-restful"
-	"github.com/pkg/errors"
-	corev1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	model "kubesphere.io/kubesphere/pkg/models/monitoring"
-	"kubesphere.io/kubesphere/pkg/simple/client/monitoring"
-	"strconv"
-	"time"
-)
-
-const (
-	DefaultStep   = 10 * time.Minute
-	DefaultFilter = ".*"
-	DefaultOrder  = model.OrderDescending
-	DefaultPage   = 1
-	DefaultLimit  = 5
-)
-
-type params struct {
-	time       time.Time
-	start, end time.Time
-	step       time.Duration
-
-	target     string
-	identifier string
-	order      string
-	page       int
-	limit      int
-
-	option monitoring.QueryOption
-}
-
-func (p params) isRangeQuery() bool {
-	return !p.time.IsZero()
-}
-
-func (p params) shouldSort() bool {
-	return p.target != ""
-}
-
-func (h handler) parseRequestParams(req *restful.Request, lvl monitoring.MonitoringLevel) (params, error) {
-	timestamp := req.QueryParameter("time")
-	start := req.QueryParameter("start")
-	end := req.QueryParameter("end")
-	step := req.QueryParameter("step")
-	target := req.QueryParameter("sort_metric")
-	order := req.QueryParameter("sort_type")
-	page := req.QueryParameter("page")
-	limit := req.QueryParameter("limit")
-	metricFilter := req.QueryParameter("metrics_filter")
-	resourceFilter := req.QueryParameter("resources_filter")
-	nodeName := req.PathParameter("node")
-	workspaceName := req.PathParameter("workspace")
-	namespaceName := req.PathParameter("namespace")
-	workloadKind := req.PathParameter("kind")
-	workloadName := req.PathParameter("workload")
-	podName := req.PathParameter("pod")
-	containerName := req.PathParameter("container")
-	pvcName := req.PathParameter("pvc")
-	storageClassName := req.PathParameter("storageclass")
-	componentType := req.PathParameter("component")
-
-	var p params
-	var err error
-	if start != "" && end != "" {
-		p.start, err = time.Parse(time.RFC3339, start)
-		if err != nil {
-			return p, err
-		}
-		p.end, err = time.Parse(time.RFC3339, end)
-		if err != nil {
-			return p, err
-		}
-		if step == "" {
-			p.step = DefaultStep
-		} else {
-			p.step, err = time.ParseDuration(step)
-			if err != nil {
-				return p, err
-			}
-		}
-	} else if start == "" && end == "" {
-		if timestamp == "" {
-			p.time = time.Now()
-		} else {
-			p.time, err = time.Parse(time.RFC3339, req.QueryParameter("time"))
-			if err != nil {
-				return p, err
-			}
-		}
-	} else {
-		return p, errors.Errorf("'time' and the combination of 'start' and 'end' are mutually exclusive.")
-	}
-
-	// hide metrics from a deleted namespace having the same name
-	namespace := req.QueryParameter("namespace")
-	if req.QueryParameter("namespace") != "" {
-		ns, err := h.k.Kubernetes().CoreV1().Namespaces().Get(namespace, corev1.GetOptions{})
-		if err != nil {
-			return p, err
-		}
-
-		cts := ns.CreationTimestamp.Time
-		if p.start.Before(cts) {
-			p.start = cts
-		}
-		if p.end.Before(cts) {
-			return p, errors.Errorf("End timestamp must not be before namespace creation time.")
-		}
-	}
-
-	if resourceFilter == "" {
-		resourceFilter = DefaultFilter
-	}
-
-	if metricFilter == "" {
-		metricFilter = DefaultFilter
-	}
-	if componentType != "" {
-		metricFilter = fmt.Sprintf("/^(?=.*%s)(?=.*%s)/s", componentType, metricFilter)
-	}
-
-	// should sort
-	if target != "" {
-		p.page = DefaultPage
-		p.limit = DefaultLimit
-		if order != model.OrderAscending {
-			p.order = DefaultOrder
-		}
-		if page != "" {
-			p.page, err = strconv.Atoi(req.QueryParameter("page"))
-			if err != nil || p.page <= 0 {
-				return p, errors.Errorf("Invalid parameter 'page'.")
-			}
-		}
-		if limit != "" {
-			p.limit, err = strconv.Atoi(req.QueryParameter("limit"))
-			if err != nil || p.limit <= 0 {
-				return p, errors.Errorf("Invalid parameter 'limit'.")
-			}
-		}
-	}
-
-	switch lvl {
-	case monitoring.LevelCluster:
-		p.option = monitoring.ClusterOption{MetricFilter: metricFilter}
-	case monitoring.LevelNode:
-		p.identifier = model.IdentifierNode
-		p.option = monitoring.NodeOption{
-			MetricFilter:   metricFilter,
-			ResourceFilter: resourceFilter,
-			NodeName:       nodeName,
-		}
-	case monitoring.LevelWorkspace:
-		p.identifier = model.IdentifierWorkspace
-		p.option = monitoring.WorkspaceOption{
-			MetricFilter:   metricFilter,
-			ResourceFilter: resourceFilter,
-			WorkspaceName:  workspaceName,
-		}
-	case monitoring.LevelNamespace:
-		p.identifier = model.IdentifierNamespace
-		p.option = monitoring.NamespaceOption{
-			MetricFilter:   metricFilter,
-			ResourceFilter: resourceFilter,
-			WorkspaceName:  workspaceName,
-			NamespaceName:  namespaceName,
-		}
-	case monitoring.LevelWorkload:
-		p.identifier = model.IdentifierWorkload
-		p.option = monitoring.WorkloadOption{
-			MetricFilter:   metricFilter,
-			ResourceFilter: resourceFilter,
-			NamespaceName:  namespaceName,
-			WorkloadKind:   workloadKind,
-			WorkloadName:   workloadName,
-		}
-	case monitoring.LevelPod:
-		p.identifier = model.IdentifierPod
-		p.option = monitoring.PodOption{
-			MetricFilter:   metricFilter,
-			ResourceFilter: resourceFilter,
-			NodeName:       nodeName,
-			NamespaceName:  namespaceName,
-			WorkloadKind:   workloadKind,
-			WorkloadName:   workloadName,
-			PodName:        podName,
-		}
-	case monitoring.LevelContainer:
-		p.identifier = model.IdentifierContainer
-		p.option = monitoring.ContainerOption{
-			MetricFilter:   metricFilter,
-			ResourceFilter: resourceFilter,
-			NamespaceName:  namespaceName,
-			PodName:        podName,
-			ContainerName:  containerName,
-		}
-	case monitoring.LevelPVC:
-		p.identifier = model.IdentifierPVC
-		p.option = monitoring.PVCOption{
-			MetricFilter:              metricFilter,
-			ResourceFilter:            resourceFilter,
-			NamespaceName:             namespaceName,
-			StorageClassName:          storageClassName,
-			PersistentVolumeClaimName: pvcName,
-		}
-	case monitoring.LevelComponent:
-		p.option = monitoring.ComponentOption{
-			MetricFilter: metricFilter,
-		}
-	}
-
-	return p, nil
-}

pkg/kapis/monitoring/v1alpha3/handler.go

@@ -0,0 +1,194 @@
+/*
+
+ 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 v1alpha3
+
+import (
+	"github.com/emicklei/go-restful"
+	"k8s.io/client-go/kubernetes"
+	"kubesphere.io/kubesphere/pkg/api"
+	model "kubesphere.io/kubesphere/pkg/models/monitoring"
+	"kubesphere.io/kubesphere/pkg/simple/client/monitoring"
+	"regexp"
+)
+
+type handler struct {
+	k  kubernetes.Interface
+	mo model.MonitoringOperator
+}
+
+func newHandler(k kubernetes.Interface, m monitoring.Interface) *handler {
+	return &handler{k, model.NewMonitoringOperator(m)}
+}
+
+func (h handler) handleClusterMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelCluster)
+	if err != nil {
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handleNodeMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelNode)
+	if err != nil {
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handleWorkspaceMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelWorkspace)
+	if err != nil {
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handleNamespaceMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelNamespace)
+	if err != nil {
+		if err.Error() == ErrNoHit {
+			res := handleNoHit(opt.namedMetrics)
+			resp.WriteAsJson(res)
+			return
+		}
+
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handleWorkloadMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelWorkload)
+	if err != nil {
+		if err.Error() == ErrNoHit {
+			res := handleNoHit(opt.namedMetrics)
+			resp.WriteAsJson(res)
+			return
+		}
+
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handlePodMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelPod)
+	if err != nil {
+		if err.Error() == ErrNoHit {
+			res := handleNoHit(opt.namedMetrics)
+			resp.WriteAsJson(res)
+			return
+		}
+
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handleContainerMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelContainer)
+	if err != nil {
+		if err.Error() == ErrNoHit {
+			res := handleNoHit(opt.namedMetrics)
+			resp.WriteAsJson(res)
+			return
+		}
+
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handlePVCMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelPVC)
+	if err != nil {
+		if err.Error() == ErrNoHit {
+			res := handleNoHit(opt.namedMetrics)
+			resp.WriteAsJson(res)
+			return
+		}
+
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func (h handler) handleComponentMetricsQuery(req *restful.Request, resp *restful.Response) {
+	params := parseRequestParams(req)
+	opt, err := h.makeQueryOptions(params, monitoring.LevelComponent)
+	if err != nil {
+		api.HandleBadRequest(resp, nil, err)
+		return
+	}
+	h.handleNamedMetricsQuery(resp, opt)
+}
+
+func handleNoHit(namedMetrics []string) model.Metrics {
+	var res model.Metrics
+	for _, metic := range namedMetrics {
+		res.Results = append(res.Results, monitoring.Metric{
+			MetricName: metic,
+			MetricData: monitoring.MetricData{},
+		})
+	}
+	return res
+}
+
+func (h handler) handleNamedMetricsQuery(resp *restful.Response, q queryOptions) {
+	var res model.Metrics
+
+	var metrics []string
+	for _, metric := range q.namedMetrics {
+		ok, _ := regexp.MatchString(q.metricFilter, metric)
+		if ok {
+			metrics = append(metrics, metric)
+		}
+	}
+	if len(metrics) == 0 {
+		resp.WriteAsJson(res)
+		return
+	}
+
+	if q.isRangeQuery() {
+		res = h.mo.GetNamedMetricsOverTime(metrics, q.start, q.end, q.step, q.option)
+	} else {
+		res = h.mo.GetNamedMetrics(metrics, q.time, q.option)
+		if q.shouldSort() {
+			res = *res.Sort(q.target, q.order, q.identifier).Page(q.page, q.limit)
+		}
+	}
+	resp.WriteAsJson(res)
+}

pkg/kapis/monitoring/v1alpha3/helper.go

@@ -0,0 +1,268 @@
+package v1alpha3
+
+import (
+	"github.com/emicklei/go-restful"
+	"github.com/pkg/errors"
+	corev1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	model "kubesphere.io/kubesphere/pkg/models/monitoring"
+	"kubesphere.io/kubesphere/pkg/simple/client/monitoring"
+	"strconv"
+	"time"
+)
+
+const (
+	DefaultStep   = 10 * time.Minute
+	DefaultFilter = ".*"
+	DefaultOrder  = model.OrderDescending
+	DefaultPage   = 1
+	DefaultLimit  = 5
+
+	ComponentEtcd      = "etcd"
+	ComponentAPIServer = "apiserver"
+	ComponentScheduler = "scheduler"
+
+	ErrNoHit           = "'end' must be after the namespace creation time."
+	ErrParamConflict   = "'time' and the combination of 'start' and 'end' are mutually exclusive."
+	ErrInvalidStartEnd = "'start' must be before 'end'."
+	ErrInvalidPage     = "Invalid parameter 'page'."
+	ErrInvalidLimit    = "Invalid parameter 'limit'."
+)
+
+type reqParams struct {
+	time             string
+	start            string
+	end              string
+	step             string
+	target           string
+	order            string
+	page             string
+	limit            string
+	metricFilter     string
+	resourceFilter   string
+	nodeName         string
+	workspaceName    string
+	namespaceName    string
+	workloadKind     string
+	workloadName     string
+	podName          string
+	containerName    string
+	pvcName          string
+	storageClassName string
+	componentType    string
+}
+
+type queryOptions struct {
+	metricFilter string
+	namedMetrics []string
+
+	start time.Time
+	end   time.Time
+	time  time.Time
+	step  time.Duration
+
+	target     string
+	identifier string
+	order      string
+	page       int
+	limit      int
+
+	option monitoring.QueryOption
+}
+
+func (q queryOptions) isRangeQuery() bool {
+	return !q.time.IsZero()
+}
+
+func (q queryOptions) shouldSort() bool {
+	return q.target != "" && q.identifier != ""
+}
+
+func parseRequestParams(req *restful.Request) reqParams {
+	var r reqParams
+	r.time = req.QueryParameter("time")
+	r.start = req.QueryParameter("start")
+	r.end = req.QueryParameter("end")
+	r.step = req.QueryParameter("step")
+	r.target = req.QueryParameter("sort_metric")
+	r.order = req.QueryParameter("sort_type")
+	r.page = req.QueryParameter("page")
+	r.limit = req.QueryParameter("limit")
+	r.metricFilter = req.QueryParameter("metrics_filter")
+	r.resourceFilter = req.QueryParameter("resources_filter")
+	r.nodeName = req.PathParameter("node")
+	r.workspaceName = req.PathParameter("workspace")
+	r.namespaceName = req.PathParameter("namespace")
+	r.workloadKind = req.PathParameter("kind")
+	r.workloadName = req.PathParameter("workload")
+	r.podName = req.PathParameter("pod")
+	r.containerName = req.PathParameter("container")
+	r.pvcName = req.PathParameter("pvc")
+	r.storageClassName = req.PathParameter("storageclass")
+	r.componentType = req.PathParameter("component")
+	return r
+}
+
+func (h handler) makeQueryOptions(r reqParams, lvl monitoring.Level) (q queryOptions, err error) {
+	if r.resourceFilter == "" {
+		r.resourceFilter = DefaultFilter
+	}
+
+	q.metricFilter = r.metricFilter
+	if r.metricFilter == "" {
+		q.metricFilter = DefaultFilter
+	}
+
+	switch lvl {
+	case monitoring.LevelCluster:
+		q.option = monitoring.ClusterOption{}
+		q.namedMetrics = model.ClusterMetrics
+	case monitoring.LevelNode:
+		q.identifier = model.IdentifierNode
+		q.namedMetrics = model.NodeMetrics
+		q.option = monitoring.NodeOption{
+			ResourceFilter: r.resourceFilter,
+			NodeName:       r.nodeName,
+		}
+	case monitoring.LevelWorkspace:
+		q.identifier = model.IdentifierWorkspace
+		q.namedMetrics = model.WorkspaceMetrics
+		q.option = monitoring.WorkspaceOption{
+			ResourceFilter: r.resourceFilter,
+			WorkspaceName:  r.workspaceName,
+		}
+	case monitoring.LevelNamespace:
+		q.identifier = model.IdentifierNamespace
+		q.namedMetrics = model.NamespaceMetrics
+		q.option = monitoring.NamespaceOption{
+			ResourceFilter: r.resourceFilter,
+			WorkspaceName:  r.workspaceName,
+			NamespaceName:  r.namespaceName,
+		}
+	case monitoring.LevelWorkload:
+		q.identifier = model.IdentifierWorkload
+		q.namedMetrics = model.WorkloadMetrics
+		q.option = monitoring.WorkloadOption{
+			ResourceFilter: r.resourceFilter,
+			NamespaceName:  r.namespaceName,
+			WorkloadKind:   r.workloadKind,
+		}
+	case monitoring.LevelPod:
+		q.identifier = model.IdentifierPod
+		q.namedMetrics = model.PodMetrics
+		q.option = monitoring.PodOption{
+			ResourceFilter: r.resourceFilter,
+			NodeName:       r.nodeName,
+			NamespaceName:  r.namespaceName,
+			WorkloadKind:   r.workloadKind,
+			WorkloadName:   r.workloadName,
+			PodName:        r.podName,
+		}
+	case monitoring.LevelContainer:
+		q.identifier = model.IdentifierContainer
+		q.namedMetrics = model.ContainerMetrics
+		q.option = monitoring.ContainerOption{
+			ResourceFilter: r.resourceFilter,
+			NamespaceName:  r.namespaceName,
+			PodName:        r.podName,
+			ContainerName:  r.containerName,
+		}
+	case monitoring.LevelPVC:
+		q.identifier = model.IdentifierPVC
+		q.namedMetrics = model.PVCMetrics
+		q.option = monitoring.PVCOption{
+			ResourceFilter:            r.resourceFilter,
+			NamespaceName:             r.namespaceName,
+			StorageClassName:          r.storageClassName,
+			PersistentVolumeClaimName: r.pvcName,
+		}
+	case monitoring.LevelComponent:
+		q.option = monitoring.ComponentOption{}
+		switch r.componentType {
+		case ComponentEtcd:
+			q.namedMetrics = model.EtcdMetrics
+		case ComponentAPIServer:
+			q.namedMetrics = model.APIServerMetrics
+		case ComponentScheduler:
+			q.namedMetrics = model.SchedulerMetrics
+		}
+	}
+
+	// Parse time params
+	if r.start != "" && r.end != "" {
+		startInt, err := strconv.ParseInt(r.start, 10, 64)
+		if err != nil {
+			return q, err
+		}
+		q.start = time.Unix(startInt, 0)
+
+		endInt, err := strconv.ParseInt(r.end, 10, 64)
+		if err != nil {
+			return q, err
+		}
+		q.end = time.Unix(endInt, 0)
+
+		if r.step == "" {
+			q.step = DefaultStep
+		} else {
+			q.step, err = time.ParseDuration(r.step)
+			if err != nil {
+				return q, err
+			}
+		}
+
+		if q.start.After(q.end) {
+			return q, errors.New(ErrInvalidStartEnd)
+		}
+	} else if r.start == "" && r.end == "" {
+		if r.time == "" {
+			q.time = time.Now()
+		} else {
+			timeInt, err := strconv.ParseInt(r.time, 10, 64)
+			if err != nil {
+				return q, err
+			}
+			q.time = time.Unix(timeInt, 0)
+		}
+	} else {
+		return q, errors.Errorf(ErrParamConflict)
+	}
+
+	// Ensure query start time to be after the namespace creation time
+	if r.namespaceName != "" {
+		ns, err := h.k.CoreV1().Namespaces().Get(r.namespaceName, corev1.GetOptions{})
+		if err != nil {
+			return q, err
+		}
+
+		cts := ns.CreationTimestamp.Time
+		if q.start.Before(cts) {
+			q.start = cts
+		}
+		if q.end.Before(cts) {
+			return q, errors.New(ErrNoHit)
+		}
+	}
+
+	// Parse sorting and paging params
+	if r.target != "" {
+		q.page = DefaultPage
+		q.limit = DefaultLimit
+		if q.order != model.OrderAscending {
+			r.order = DefaultOrder
+		}
+		if r.page != "" {
+			q.page, err = strconv.Atoi(r.page)
+			if err != nil || q.page <= 0 {
+				return q, errors.New(ErrInvalidPage)
+			}
+		}
+		if r.limit != "" {
+			q.limit, err = strconv.Atoi(r.limit)
+			if err != nil || q.limit <= 0 {
+				return q, errors.New(ErrInvalidLimit)
+			}
+		}
+	}
+
+	return q, nil
+}

pkg/kapis/monitoring/v1alpha3/helper_test.go

@@ -0,0 +1,148 @@
+package v1alpha3
+
+import (
+	"fmt"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes/fake"
+	model "kubesphere.io/kubesphere/pkg/models/monitoring"
+	"kubesphere.io/kubesphere/pkg/simple/client/monitoring"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestParseRequestParams(t *testing.T) {
+	tests := []struct {
+		params      reqParams
+		lvl         monitoring.Level
+		namespace   corev1.Namespace
+		expected    queryOptions
+		expectedErr bool
+	}{
+		{
+			params: reqParams{
+				time: "abcdef",
+			},
+			lvl:         monitoring.LevelCluster,
+			expectedErr: true,
+		},
+		{
+			params: reqParams{
+				time: "1585831995",
+			},
+			lvl: monitoring.LevelCluster,
+			expected: queryOptions{
+				time:         time.Unix(1585831995, 0),
+				metricFilter: ".*",
+				namedMetrics: model.ClusterMetrics,
+				option:       monitoring.ClusterOption{},
+			},
+			expectedErr: false,
+		},
+		{
+			params: reqParams{
+				start:         "1585830000",
+				end:           "1585839999",
+				step:          "1m",
+				namespaceName: "default",
+			},
+			lvl: monitoring.LevelNamespace,
+			namespace: corev1.Namespace{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "default",
+					CreationTimestamp: metav1.Time{
+						Time: time.Unix(1585836666, 0),
+					},
+				},
+			},
+			expected: queryOptions{
+				start:        time.Unix(1585836666, 0),
+				end:          time.Unix(1585839999, 0),
+				step:         time.Minute,
+				identifier:   model.IdentifierNamespace,
+				metricFilter: ".*",
+				namedMetrics: model.NamespaceMetrics,
+				option: monitoring.NamespaceOption{
+					ResourceFilter: ".*",
+					NamespaceName:  "default",
+				},
+			},
+			expectedErr: false,
+		},
+		{
+			params: reqParams{
+				start:         "1585830000",
+				end:           "1585839999",
+				step:          "1m",
+				namespaceName: "default",
+			},
+			lvl: monitoring.LevelNamespace,
+			namespace: corev1.Namespace{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "default",
+					CreationTimestamp: metav1.Time{
+						Time: time.Unix(1589999999, 0),
+					},
+				},
+			},
+			expectedErr: true,
+		},
+		{
+			params: reqParams{
+				start:         "1585830000",
+				end:           "1585839999",
+				step:          "1m",
+				namespaceName: "non-exist",
+			},
+			lvl: monitoring.LevelNamespace,
+			namespace: corev1.Namespace{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "default",
+					CreationTimestamp: metav1.Time{
+						Time: time.Unix(1589999999, 0),
+					},
+				},
+			},
+			expectedErr: true,
+		},
+		{
+			params: reqParams{
+				time:          "1585830000",
+				componentType: "etcd",
+				metricFilter:  "etcd_server_list",
+			},
+			lvl: monitoring.LevelComponent,
+			expected: queryOptions{
+				time:         time.Unix(1585830000, 0),
+				metricFilter: "etcd_server_list",
+				namedMetrics: model.EtcdMetrics,
+				option:       monitoring.ComponentOption{},
+			},
+			expectedErr: false,
+		},
+	}
+
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
+			client := fake.NewSimpleClientset(&tt.namespace)
+			handler := newHandler(client, nil)
+
+			result, err := handler.makeQueryOptions(tt.params, tt.lvl)
+			if err != nil {
+				if !tt.expectedErr {
+					t.Fatalf("unexpected err: %s.", err.Error())
+				}
+				return
+			}
+
+			if tt.expectedErr {
+				t.Fatalf("failed to catch error.")
+			}
+
+			if !reflect.DeepEqual(result, tt.expected) {
+				t.Fatalf("unexpected return: %v.", result)
+			}
+		})
+	}
+}

pkg/kapis/monitoring/v1alpha3/register.go

@@ -15,16 +15,16 @@
  limitations under the License.
 
 */
-package v1alpha2
+package v1alpha3
 
 import (
 	"github.com/emicklei/go-restful"
 	"github.com/emicklei/go-restful-openapi"
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	"kubesphere.io/kubesphere/pkg/api/monitoring/v1alpha2"
+	"k8s.io/client-go/kubernetes"
 	"kubesphere.io/kubesphere/pkg/apiserver/runtime"
 	"kubesphere.io/kubesphere/pkg/constants"
-	"kubesphere.io/kubesphere/pkg/simple/client/k8s"
+	model "kubesphere.io/kubesphere/pkg/models/monitoring"
 	"kubesphere.io/kubesphere/pkg/simple/client/monitoring"
 	"net/http"
 )
@@ -36,7 +36,7 @@ const (
 
 var GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha2"}
 
-func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient monitoring.Interface) error {
+func AddToContainer(c *restful.Container, k8sClient kubernetes.Interface, monitoringClient monitoring.Interface) error {
 	ws := runtime.NewWebService(GroupVersion)
 
 	h := newHandler(k8sClient, monitoringClient)
@@ -50,8 +50,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.ClusterMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/nodes").
@@ -68,8 +68,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.NodeMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/nodes/{node}").
@@ -82,8 +82,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.NodeMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/workspaces").
@@ -100,8 +100,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.WorkspaceMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/workspaces/{workspace}").
@@ -114,8 +114,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.WorkspaceMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/workspaces/{workspace}/namespaces").
@@ -133,8 +133,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.NamespaceMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces").
@@ -151,8 +151,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.NamespaceMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}").
@@ -165,8 +165,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.NamespaceMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/workloads").
@@ -184,8 +184,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.WorkloadMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/workloads/{kind}").
@@ -204,8 +204,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.WorkloadMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/pods").
@@ -223,8 +223,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PodMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/pods/{pod}").
@@ -238,8 +238,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PodMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/workloads/{kind}/{workload}/pods").
@@ -259,8 +259,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PodMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/nodes/{node}/pods").
@@ -278,8 +278,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PodMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/nodes/{node}/pods/{pod}").
@@ -293,8 +293,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PodMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/pods/{pod}/containers").
@@ -313,8 +313,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.ContainerMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/pods/{pod}/containers/{container}").
@@ -329,8 +329,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.ContainerMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/storageclasses/{storageclass}/persistentvolumeclaims").
@@ -348,8 +348,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PVCMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/persistentvolumeclaims").
@@ -367,8 +367,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("page", "The page number. This field paginates result data of each metric, then returns a specific page. For example, setting **page** to 2 returns the second page. It only applies to sorted metric data.").DataType("integer").Required(false)).
 		Param(ws.QueryParameter("limit", "Page size, the maximum number of results in a single page. Defaults to 5.").DataType("integer").Required(false).DefaultValue("5")).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PVCMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/namespaces/{namespace}/persistentvolumeclaims/{pvc}").
@@ -382,8 +382,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.PVCMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	ws.Route(ws.GET("/components/{component}").
@@ -396,8 +396,8 @@ func AddToContainer(c *restful.Container, k8sClient k8s.Client, monitoringClient
 		Param(ws.QueryParameter("step", "Time interval. Retrieve metric data at a fixed interval within the time range of start and end. It requires both **start** and **end** are provided. The format is [0-9]+[smhdwy]. Defaults to 10m (i.e. 10 min).").DataType("string").DefaultValue("10m").Required(false)).
 		Param(ws.QueryParameter("time", "A timestamp in Unix time format. Retrieve metric data at a single point in time. Defaults to now. Time and the combination of start, end, step are mutually exclusive.").DataType("string").Required(false)).
 		Metadata(restfulspec.KeyOpenAPITags, []string{constants.ComponentMetricsTag}).
-		Writes(v1alpha2.APIResponse{}).
-		Returns(http.StatusOK, RespOK, v1alpha2.APIResponse{})).
+		Writes(model.Metrics{}).
+		Returns(http.StatusOK, RespOK, model.Metrics{})).
 		Produces(restful.MIME_JSON)
 
 	c.Add(ws)