github.com/jingruilea/kubeedge@v1.2.0-beta.0.0.20200410162146-4bb8902b3879/edge/test/test.go

package test

import (
	"encoding/json"
	"io"
	"io/ioutil"
	"net/http"
	"sync"
	"time"

	"k8s.io/api/core/v1"
	"k8s.io/klog"

	"github.com/kubeedge/beehive/pkg/core"
	beehiveContext "github.com/kubeedge/beehive/pkg/core/context"
	"github.com/kubeedge/beehive/pkg/core/model"
	"github.com/kubeedge/kubeedge/edge/pkg/common/message"
	"github.com/kubeedge/kubeedge/edge/pkg/common/modules"
	"github.com/kubeedge/kubeedge/pkg/apis/componentconfig/edgecore/v1alpha1"
)

const (
	name            = "testManager"
	edgedEndPoint   = "http://127.0.0.1:10255"
	EdgedPodHandler = "/pods"
)

// TODO move this files into /edge/pkg/dbtest @kadisi
func Register(t *v1alpha1.DBTest) {
	core.Register(&testManager{enable: t.Enable})
}

type testManager struct {
	moduleWait *sync.WaitGroup
	enable     bool
}

func (tm *testManager) Name() string {
	return name
}

func (tm *testManager) Group() string {
	//return core.MetaGroup
	return modules.MetaGroup
}

func (tm *testManager) Enable() bool {
	return tm.enable
}

//Function to get the pods from Edged
func GetPodListFromEdged(w http.ResponseWriter) error {
	var pods v1.PodList
	var bytes io.Reader
	client := &http.Client{}
	t := time.Now()
	req, err := http.NewRequest(http.MethodGet, edgedEndPoint+EdgedPodHandler, bytes)
	req.Header.Set("Content-Type", "application/json; charset=utf-8")
	if err != nil {
		klog.Errorf("Frame HTTP request failed: %v", err)
		return err
	}
	resp, err := client.Do(req)
	if err != nil {
		klog.Errorf("Sending HTTP request failed: %v", err)
		return err
	}
	klog.Infof("%s %s %v in %v", req.Method, req.URL, resp.Status, time.Now().Sub(t))
	defer resp.Body.Close()
	contents, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		klog.Errorf("HTTP Response reading has failed: %v", err)
		return err
	}
	err = json.Unmarshal(contents, &pods)
	if err != nil {
		klog.Errorf("Json Unmarshal has failed: %v", err)
		return err
	}
	respBody, err := json.Marshal(pods)
	if err != nil {
		klog.Errorf("Json Marshal failed: %v", err)
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.Write(respBody)

	return nil
}

//Function to handle Get/Add/Delete deployment list.
func (tm *testManager) podHandler(w http.ResponseWriter, req *http.Request) {
	var operation string
	var p v1.Pod
	if req.Method == http.MethodGet {
		err := GetPodListFromEdged(w)
		if err != nil {
			klog.Errorf("Get podlist from Edged has failed: %v", err)
		}
	} else if req.Body != nil {
		body, err := ioutil.ReadAll(req.Body)
		if err != nil {
			klog.Errorf("read body error %v", err)
			w.Write([]byte("read request body error"))
		}
		klog.Infof("request body is %s\n", string(body))
		if err = json.Unmarshal(body, &p); err != nil {
			klog.Errorf("unmarshal request body error %v", err)
			w.Write([]byte("unmarshal request body error"))
		}

		switch req.Method {
		case "POST":
			operation = model.InsertOperation
		case "DELETE":
			operation = model.DeleteOperation
		case "PUT":
			operation = model.UpdateOperation
		}

		ns := v1.NamespaceDefault
		if p.Namespace != "" {
			ns = p.Namespace
		}
		msgReq := message.BuildMsg("resource", string(p.UID), "edgecontroller", ns+"/pod/"+string(p.Name), operation, p)
		beehiveContext.Send("metaManager", *msgReq)
		klog.Infof("send message to metaManager is %+v\n", msgReq)
	}
}

//Function to handle device addition and removal from the edgenode
func (tm *testManager) deviceHandler(w http.ResponseWriter, req *http.Request) {
	var operation string
	var Content interface{}

	if req.Body != nil {
		body, err := ioutil.ReadAll(req.Body)
		if err != nil {
			klog.Errorf("read body error %v", err)
			w.Write([]byte("read request body error"))
		}
		klog.Infof("request body is %s\n", string(body))
		err = json.Unmarshal(body, &Content)
		if err != nil {
			klog.Errorf("unmarshal request body error %v", err)
			w.Write([]byte("unmarshal request body error"))
		}
		switch req.Method {
		case "POST":
			operation = model.InsertOperation
		case "DELETE":
			operation = model.DeleteOperation
		case "PUT":
			operation = model.UpdateOperation
		}
		msgReq := message.BuildMsg("edgehub", "", "edgemgr", "membership", operation, Content)
		beehiveContext.Send("twin", *msgReq)
		klog.Infof("send message to twingrp is %+v\n", msgReq)
	}
}

func (tm *testManager) secretHandler(w http.ResponseWriter, req *http.Request) {
	var operation string
	var p v1.Secret
	if req.Body != nil {
		body, err := ioutil.ReadAll(req.Body)
		if err != nil {
			klog.Errorf("read body error %v", err)
			w.Write([]byte("read request body error"))
		}
		klog.Infof("request body is %s\n", string(body))
		if err = json.Unmarshal(body, &p); err != nil {
			klog.Errorf("unmarshal request body error %v", err)
			w.Write([]byte("unmarshal request body error"))
		}

		switch req.Method {
		case "POST":
			operation = model.InsertOperation
		case "DELETE":
			operation = model.DeleteOperation
		case "PUT":
			operation = model.UpdateOperation
		}

		msgReq := message.BuildMsg("edgehub", string(p.UID), "test", "fakeNamespace/secret/"+string(p.UID), operation, p)
		beehiveContext.Send("metaManager", *msgReq)
		klog.Infof("send message to metaManager is %+v\n", msgReq)
	}
}

func (tm *testManager) configmapHandler(w http.ResponseWriter, req *http.Request) {
	var operation string
	var p v1.ConfigMap
	if req.Body != nil {
		body, err := ioutil.ReadAll(req.Body)
		if err != nil {
			klog.Errorf("read body error %v", err)
			w.Write([]byte("read request body error"))
		}
		klog.Infof("request body is %s\n", string(body))
		if err = json.Unmarshal(body, &p); err != nil {
			klog.Errorf("unmarshal request body error %v", err)
			w.Write([]byte("unmarshal request body error"))
		}

		switch req.Method {
		case "POST":
			operation = model.InsertOperation
		case "DELETE":
			operation = model.DeleteOperation
		case "PUT":
			operation = model.UpdateOperation
		}

		msgReq := message.BuildMsg("edgehub", string(p.UID), "test", "fakeNamespace/configmap/"+string(p.UID), operation, p)
		beehiveContext.Send("metaManager", *msgReq)
		klog.Infof("send message to metaManager is %+v\n", msgReq)
	}
}

func (tm *testManager) Start() {

	http.HandleFunc("/pods", tm.podHandler)
	http.HandleFunc("/configmap", tm.configmapHandler)
	http.HandleFunc("/secret", tm.secretHandler)
	http.HandleFunc("/devices", tm.deviceHandler)
	err := http.ListenAndServe(":12345", nil)
	if err != nil {
		klog.Errorf("ListenAndServe: %v", err)
	}
}