Merge pull request #94 from linkernetworks/alex/addPrometheusTesting

VX-172 Add prometheus testing

Former-commit-id: 0780526b7e77a869574fa11e5eb614df91a8d61a [formerly 0780526b7e77a869574fa11e5eb614df91a8d61a [formerly 7ee8e63]]
Former-commit-id: 03671197e950a65ed4a7cec5d86a720f30fca5ab
Former-commit-id: 58b2beb

.travis.yml

@@ -24,7 +24,7 @@ install:
 script:
   - docker run --name prometheus -d -p 9090:9090 prom/prometheus
   - make build
-  - sudo -E PATH=$PATH TEST_PROMETHEUS=1 TEST_GRPC=1 make src.test-coverage
+  - sudo -E PATH=$PATH TEST_GRPC=1 make src.test-coverage
   - if [ "$TRAVIS_BRANCH" == "develop" ]; then docker build --tag sdnvortex/vortex --file ./dockerfiles/Dockerfile . ; fi
 
 before_deploy:

Jenkinsfile

@@ -62,7 +62,7 @@ pipeline {
         }
         stage('Test') {
             steps {
-                withEnv(["GOPATH+AA=${env.WORKSPACE}", "TEST_PROMETHEUS=1"]) {
+                withEnv(["GOPATH+AA=${env.WORKSPACE}"]) {
                     dir ("src/github.com/linkernetworks/vortex") {
                         sh "make src.test-coverage 2>&1 | tee >(go-junit-report > report.xml)"
                         junit "report.xml"

src/kubernetes/deployment.go

@@ -14,6 +14,18 @@ func (kc *KubeCtl) GetDeployment(name string) (*appsv1.Deployment, error) {
 	return kc.Clientset.AppsV1().Deployments(kc.Namespace).Get(name, metav1.GetOptions{})
 }
 
+func (kc *KubeCtl) GetDeployments() ([]*appsv1.Deployment, error) {
+	deployments := []*appsv1.Deployment{}
+	deploymentsList, err := kc.Clientset.AppsV1().Deployments(kc.Namespace).List(metav1.ListOptions{})
+	if err != nil {
+		return deployments, err
+	}
+	for _, d := range deploymentsList.Items {
+		deployments = append(deployments, &d)
+	}
+	return deployments, nil
+}
+
 func (kc *KubeCtl) DeleteDeployment(name string) error {
 	return kc.Clientset.AppsV1().Deployments(kc.Namespace).Delete(name, &metav1.DeleteOptions{})
 }

src/kubernetes/deployment_test.go

@@ -51,6 +51,11 @@ func (suite *KubeCtlDeploymentTestSuite) TestCreateDeployment() {
 	suite.NoError(err)
 	suite.NotNil(deploy)
 	suite.Equal(replicas, *deploy.Spec.Replicas)
+
+	deploys, err := suite.kubectl.GetDeployments()
+	suite.NoError(err)
+	suite.NotNil(deploys)
+	suite.Equal(replicas, *deploys[0].Spec.Replicas)
 }
 
 func (suite *KubeCtlDeploymentTestSuite) TestDeleteDeployment() {

src/kubernetes/kubectl.go

@@ -24,3 +24,7 @@ func New(clientset kubernetes.Interface, namespace string) *KubeCtl {
 		Namespace: namespace,
 	}
 }
+
+func (kc *KubeCtl) SetNamespace(namespace string) {
+	kc.Namespace = namespace
+}

src/kubernetes/kubectl_test.go

@@ -14,4 +14,6 @@ func TestNewKubeCtl(t *testing.T) {
 	kubectl := New(clientset, namespace)
 	assert.Equal(t, namespace, kubectl.Namespace)
 	assert.NotNil(t, kubectl)
+	// Change struct namespace field value
+	kubectl.SetNamespace("test")
 }

src/prometheuscontroller/expression_test.go

@@ -0,0 +1,108 @@
+package prometheuscontroller
+
+import (
+	"github.com/linkernetworks/vortex/src/config"
+	"github.com/linkernetworks/vortex/src/serviceprovider"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/suite"
+	"math/rand"
+	"os"
+	"testing"
+	"time"
+)
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+type PrometheusExpressionTestSuite struct {
+	suite.Suite
+	sp *serviceprovider.Container
+}
+
+func (suite *PrometheusExpressionTestSuite) SetupSuite() {
+	cf := config.MustRead("../../config/local.json")
+	suite.sp = serviceprovider.New(cf)
+	suite.sp.KubeCtl.SetNamespace("monitoring")
+}
+
+func (suite *PrometheusExpressionTestSuite) TearDownSuite() {
+}
+
+func TestPrometheusExpressionSuite(t *testing.T) {
+	if _, defined := os.LookupEnv("TEST_PROMETHEUS"); !defined {
+		t.SkipNow()
+		return
+	}
+	suite.Run(t, new(PrometheusExpressionTestSuite))
+}
+
+func (suite *PrometheusExpressionTestSuite) TestListResource() {
+	labelName := model.LabelName("container")
+	expression := Expression{}
+	expression.Metrics = []string{"kube_pod_container_info"}
+	expression.QueryLabels = map[string]string{}
+	expression.QueryLabels["namespace"] = "monitoring"
+
+	resourceList, err := ListResource(suite.sp, labelName, expression)
+	suite.NoError(err)
+	suite.NotEqual(0, len(resourceList))
+}
+
+func (suite *PrometheusExpressionTestSuite) TestListResourceFail() {
+	labelName := model.LabelName("")
+	expression := Expression{}
+
+	_, err := ListResource(suite.sp, labelName, expression)
+	suite.Error(err)
+}
+
+func (suite *PrometheusExpressionTestSuite) TestGetPod() {
+	pods, err := suite.sp.KubeCtl.GetPods()
+	suite.NoError(err)
+	podName := pods[0].GetName()
+
+	pod, err := GetPod(suite.sp, podName)
+	suite.NoError(err)
+	suite.Equal(podName, pod.PodName)
+}
+
+func (suite *PrometheusExpressionTestSuite) TestGetContainer() {
+	pods, err := suite.sp.KubeCtl.GetPods()
+	suite.NoError(err)
+	containerName := pods[0].Status.ContainerStatuses[0].Name
+
+	container, err := GetContainer(suite.sp, containerName)
+	suite.NoError(err)
+	suite.Equal(containerName, container.Detail.ContainerName)
+}
+
+func (suite *PrometheusExpressionTestSuite) TestGetService() {
+	services, err := suite.sp.KubeCtl.GetServices()
+	suite.NoError(err)
+	serviceName := services[0].GetName()
+
+	service, err := GetService(suite.sp, serviceName)
+	suite.NoError(err)
+	suite.Equal(serviceName, service.ServiceName)
+}
+
+func (suite *PrometheusExpressionTestSuite) TestGetController() {
+	deployments, err := suite.sp.KubeCtl.GetDeployments()
+	suite.NoError(err)
+	deploymentName := deployments[0].GetName()
+
+	controller, err := GetController(suite.sp, deploymentName)
+	suite.NoError(err)
+	suite.Equal(deploymentName, controller.ControllerName)
+}
+
+func (suite *PrometheusExpressionTestSuite) TestGetNode() {
+	nodes, err := suite.sp.KubeCtl.GetNodes()
+	suite.NoError(err)
+	nodeName := nodes[0].GetName()
+
+	node, err := GetNode(suite.sp, nodeName)
+	suite.NoError(err)
+	suite.Equal(nodeName, node.Detail.Hostname)
+}

src/prometheuscontroller/query.go

@@ -41,10 +41,10 @@ func query(sp *serviceprovider.Container, expression string) (model.Vector, erro
 
 func getElements(sp *serviceprovider.Container, expression Expression) (model.Vector, error) {
 	// append the metrics
+	var metrics string
 	str := `__name__=~"{{metrics}}"`
-	metrics := ""
 	for _, metric := range expression.Metrics {
-		metrics = metrics + metric + "|"
+		metrics = fmt.Sprintf("%s%s|", metrics, metric)
 	}
 	rule := strings.NewReplacer("{{metrics}}", strings.TrimSuffix(metrics, "|"))
 	str = rule.Replace(str)
@@ -54,22 +54,22 @@ func getElements(sp *serviceprovider.Container, expression Expression) (model.Ve
 	for key, value := range labels {
 		str = fmt.Sprintf(`%s,%s=~"%s"`, str, key, value)
 	}
-	str = `{` + str + `}`
+	str = fmt.Sprintf("{%s}", str)
 
 	// use sum by if need it
+	var sumby string
 	if expression.SumBy != nil {
-		str = fmt.Sprintf(`sum by({{sumby}})(%s)`, str)
-		sumby := ""
+		str = fmt.Sprintf("sum by({{sumby}})(%s)", str)
 		for _, sumLabel := range expression.SumBy {
-			sumby = sumby + sumLabel + ","
+			sumby = fmt.Sprintf("%s%s,", sumby, sumLabel)
 		}
 		rule = strings.NewReplacer("{{sumby}}", strings.TrimSuffix(sumby, ","))
 		str = rule.Replace(str)
 	}
 
 	// the result should equal to expression.Value
 	if expression.Value != nil {
-		str = fmt.Sprintf(`%s==%v`, str, *expression.Value)
+		str = fmt.Sprintf("%s==%v", str, *expression.Value)
 	}
 
 	results, err := query(sp, str)

src/prometheuscontroller/query_test.go

@@ -0,0 +1,67 @@
+package prometheuscontroller
+
+import (
+	"fmt"
+	"github.com/linkernetworks/vortex/src/config"
+	"github.com/linkernetworks/vortex/src/serviceprovider"
+	"github.com/prometheus/common/model"
+	"github.com/stretchr/testify/suite"
+	"math/rand"
+	"os"
+	"testing"
+	"time"
+)
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+type PrometheusQueryTestSuite struct {
+	suite.Suite
+	sp            *serviceprovider.Container
+	containerName string
+}
+
+func (suite *PrometheusQueryTestSuite) SetupSuite() {
+	cf := config.MustRead("../../config/local.json")
+	suite.sp = serviceprovider.New(cf)
+	suite.containerName = "cadvisor"
+}
+
+func (suite *PrometheusQueryTestSuite) TearDownSuite() {
+}
+
+func TestPrometheusQuerySuite(t *testing.T) {
+	if _, defined := os.LookupEnv("TEST_PROMETHEUS"); !defined {
+		t.SkipNow()
+		return
+	}
+	suite.Run(t, new(PrometheusQueryTestSuite))
+}
+
+func (suite *PrometheusQueryTestSuite) TestQuery() {
+	queryStr := fmt.Sprintf(`sum(rate(container_cpu_usage_seconds_total{container_label_io_kubernetes_container_name=~"%s"}[1m])) * 100`, suite.containerName)
+
+	resource, err := query(suite.sp, queryStr)
+	suite.NoError(err)
+	suite.NotEqual(0, float32(resource[0].Value))
+
+	// Get nil if the resource is empty
+	resource, err = query(suite.sp, "")
+	suite.Equal(model.Vector(nil), resource)
+}
+
+func (suite *PrometheusQueryTestSuite) TestGetElements() {
+	expression := Expression{}
+	expression.Metrics = []string{"kube_pod_container_info"}
+	expression.QueryLabels = map[string]string{}
+	expression.QueryLabels["namespace"] = "monitoring"
+
+	resource, err := getElements(suite.sp, expression)
+	suite.NoError(err)
+	suite.NotEqual(0, float32(resource[0].Value))
+
+	// Get nil if the resource is empty
+	resource, err = getElements(suite.sp, Expression{})
+	suite.Equal(model.Vector(nil), resource)
+}