test: add deamon related function

Signed-off-by: letty <[email protected]>

Author: Letty5411

test/daemon/daemon.go

@@ -0,0 +1,81 @@
+package daemon
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/alibaba/pouch/test/command"
+	"github.com/alibaba/pouch/test/util"
+	"github.com/gotestyourself/gotestyourself/icmd"
+)
+
+const (
+	DaemonLog  = "/tmp/pouch.log"
+	PouchdBin = "pouchd"
+)
+
+type DaemonConfig struct {
+	Log string
+	Args []string
+	Bin string
+	Listen []string
+}
+
+var DConfig DaemonConfig
+
+func init()  {
+	DConfig = NewDaemonConfig()
+}
+
+func NewDaemonConfig() DaemonConfig{
+	result := DaemonConfig{}
+	result.Bin = PouchdBin
+	result.Log = DaemonLog
+
+	return result
+	}
+
+// IsDaemonUp checks if the pouchd is launched.
+func (d *DaemonConfig) IsDaemonUp() bool{
+	if len(d.Listen) != 0 {
+		return command.PouchRun("-h",d.Listen[0],"version").ExitCode == 0
+	}
+
+	result := command.PouchRun("version")
+	fmt.Printf("result=%v",result)
+
+	return result.ExitCode == 0
+}
+
+// StartDaemon starts pouchd
+func (d *DaemonConfig)StartDaemon() error {
+	cmd := icmd.Command(d.Bin, d.Args...)
+	result := icmd.StartCmd(cmd)
+
+	if util.WaitTimeout(time.Second * 5, d.IsDaemonUp) == false {
+		d.KillDaemon()
+		return fmt.Errorf("faile to launch pouchd within 5s, log:%v",result)
+	}
+
+	return nil
+}
+
+// KillDaemon kill pouchd.
+func (d *DaemonConfig) KillDaemon() error {
+	if d.IsDaemonUp() == false {
+		return nil
+	}
+
+	result := icmd.RunCommand("pkill", "--signal", "9", d.Bin)
+	if result.ExitCode != 0 {
+		return fmt.Errorf("kill pouchd failed, err:%s",  result.Stderr())
+	}
+
+	for _,v := range d.Listen {
+		icmd.RunCommand("rm","-f",v)
+	}
+	return nil
+}
+
+
+

test/environment/env.go

@@ -33,4 +33,4 @@ func IsAliKernel() bool {
 		return true
 	}
 	return false
-}
+}

test/main_test.go

@@ -33,3 +33,7 @@ func TestMain(m *testing.M) {
 func Test(t *testing.T) {
 	check.TestingT(t)
 }
+
+func init()  {
+
+}

test/util/util.go

@@ -0,0 +1,38 @@
+package util
+
+import (
+	"fmt"
+	"time"
+)
+
+// WaitTimeout wait until the conditon become true or timeout.
+func WaitTimeout(timeout time.Duration, condition func () bool) bool {
+	ch := make(chan bool,1)
+
+	ticker := time.NewTicker(500*time.Millisecond)
+	defer ticker.Stop()
+
+	done := make(chan bool)
+	go func() {
+		time.Sleep(timeout)
+		done <- true
+	}()
+
+	for {
+		select {
+		case <-ch:
+			return true
+		case <-done:
+			fmt.Errorf("timeout")
+			return false
+		case <-ticker.C:
+			fmt.Printf("call condition")
+			ret := condition()
+			if ret == true {
+				ch <- true
+			}
+		}
+	}
+	return false
+}
+

test/util_api.go

@@ -0,0 +1,227 @@
+package main
+
+import (
+	"bufio"
+	"net"
+	"net/http"
+	"net/url"
+
+	"github.com/alibaba/pouch/apis/types"
+	"github.com/alibaba/pouch/test/request"
+
+	"github.com/go-check/check"
+)
+
+// CheckRespStatus checks the http.Response.Status is equal to status.
+func CheckRespStatus(c *check.C, resp *http.Response, status int) {
+	if resp.StatusCode != status {
+		got := types.Error{}
+		_ = request.DecodeBody(&got, resp.Body)
+		c.Assert(resp.StatusCode, check.Equals, status, check.Commentf("Error:%s", got.Message))
+	}
+}
+
+// CreateBusyboxContainerOk creates a busybox container and asserts success.
+func CreateBusyboxContainerOk(c *check.C, cname string, cmd ...string) {
+	// If not specified, CMD executed in container is "top".
+	if len(cmd) == 0 {
+		cmd = []string{"top"}
+	}
+
+	resp, err := CreateBusyboxContainer(c, cname, cmd...)
+	c.Assert(err, check.IsNil)
+	CheckRespStatus(c, resp, 201)
+}
+
+// CreateBusyboxContainer creates a basic container using busybox image.
+func CreateBusyboxContainer(c *check.C, cname string, cmd ...string) (*http.Response, error) {
+	q := url.Values{}
+	q.Add("name", cname)
+
+	obj := map[string]interface{}{
+		"Image":      busyboxImage,
+		"Cmd":        cmd,
+		"HostConfig": map[string]interface{}{},
+	}
+
+	path := "/containers/create"
+	query := request.WithQuery(q)
+	body := request.WithJSONBody(obj)
+	return request.Post(path, query, body)
+}
+
+// StartContainerOk starts the container and asserts success.
+func StartContainerOk(c *check.C, cname string) {
+	resp, err := StartContainer(c, cname)
+	c.Assert(err, check.IsNil)
+
+	CheckRespStatus(c, resp, 204)
+}
+
+// StartContainer starts the container.
+func StartContainer(c *check.C, cname string) (*http.Response, error) {
+	return request.Post("/containers/" + cname + "/start")
+}
+
+// DelContainerForceOk forcely deletes the container and asserts success.
+func DelContainerForceOk(c *check.C, cname string) {
+	resp, err := DelContainerForce(c, cname)
+	c.Assert(err, check.IsNil)
+
+	CheckRespStatus(c, resp, 204)
+}
+
+// DelContainerForce forcely deletes the container.
+func DelContainerForce(c *check.C, cname string) (*http.Response, error) {
+	q := url.Values{}
+	q.Add("force", "true")
+	return request.Delete("/containers/"+cname, request.WithQuery(q))
+}
+
+// StopContainerOk stops the container and asserts success..
+func StopContainerOk(c *check.C, cname string) {
+	resp, err := StopContainer(c, cname)
+	c.Assert(err, check.IsNil)
+
+	CheckRespStatus(c, resp, 204)
+}
+
+// StopContainer stops the container.
+func StopContainer(c *check.C, cname string) (*http.Response, error) {
+	return request.Post("/containers/" + cname + "/stop")
+}
+
+// PauseContainerOk pauses the container and asserts success..
+func PauseContainerOk(c *check.C, cname string) {
+	resp, err := PauseContainer(c, cname)
+	c.Assert(err, check.IsNil)
+
+	CheckRespStatus(c, resp, 204)
+}
+
+// PauseContainer pauses the container.
+func PauseContainer(c *check.C, cname string) (*http.Response, error) {
+	return request.Post("/containers/" + cname + "/pause")
+}
+
+// UnpauseContainerOk unpauses the container and asserts success..
+func UnpauseContainerOk(c *check.C, cname string) {
+	resp, err := UnpauseContainer(c, cname)
+	c.Assert(err, check.IsNil)
+
+	CheckRespStatus(c, resp, 204)
+}
+
+// UnpauseContainer unpauses the container.
+func UnpauseContainer(c *check.C, cname string) (*http.Response, error) {
+	return request.Post("/containers/" + cname + "/unpause")
+}
+
+
+// IsContainerCreated returns true is container's state is created.
+func IsContainerCreated(c *check.C, cname string) (bool, error) {
+	return isContainerStateEqual(c, cname, "created")
+}
+
+// IsContainerRunning returns true is container's state is running.
+func IsContainerRunning(c *check.C, cname string) (bool, error) {
+	return isContainerStateEqual(c, cname, "running")
+}
+
+func isContainerStateEqual(c *check.C, cname string, status string) (bool, error) {
+	resp, err := request.Get("/containers/" + cname + "/json")
+	c.Assert(err, check.IsNil)
+	CheckRespStatus(c, resp, 200)
+
+	defer resp.Body.Close()
+	got := types.ContainerJSON{}
+	err = request.DecodeBody(&got, resp.Body)
+	c.Assert(err, check.IsNil)
+
+	if got.State == nil {
+		return false, nil
+	}
+
+	return string(got.State.Status) == status, nil
+}
+
+// CreateExecEchoOk exec process's environment with "echo" CMD.
+func CreateExecEchoOk(c *check.C, cname string) string {
+	// NOTICE:
+	// All files in the obj is needed, or start a new process may hang.
+	obj := map[string]interface{}{
+		"Cmd":          []string{"echo", "test"},
+		"Detach":       true,
+		"AttachStderr": true,
+		"AttachStdout": true,
+		"AttachStdin":  true,
+		"Privileged":   false,
+		"User":         "",
+	}
+	body := request.WithJSONBody(obj)
+
+	resp, err := request.Post("/containers/"+cname+"/exec", body)
+	c.Assert(err, check.IsNil)
+	CheckRespStatus(c, resp, 201)
+
+	var got types.ExecCreateResp
+	request.DecodeBody(&got, resp.Body)
+	return got.ID
+}
+
+// StartContainerExec starts executing a process in the container.
+func StartContainerExec(c *check.C, execid string, tty bool, detach bool) (*http.Response, net.Conn, *bufio.Reader, error) {
+	obj := map[string]interface{}{
+		"Detach": detach,
+		"Tty":    tty,
+	}
+
+	return request.Hijack("/exec/"+execid+"/start",
+		request.WithHeader("Connection", "Upgrade"),
+		request.WithHeader("Upgrade", "tcp"),
+		request.WithJSONBody(obj))
+}
+
+// CreateVolume creates a volume in pouchd.
+func CreateVolume(c *check.C, name, driver string) error {
+	obj := map[string]interface{}{
+		"Driver": driver,
+		"Name":   name,
+	}
+	path := "/volumes/create"
+	body := request.WithJSONBody(obj)
+
+	resp, err := request.Post(path, body)
+	defer resp.Body.Close()
+
+	c.Assert(err, check.IsNil)
+	CheckRespStatus(c, resp, 201)
+
+	return err
+}
+
+// RemoveVolume removes a volume in pouchd.
+func RemoveVolume(c *check.C, name string) error {
+	path := "/volumes/" + name
+	resp, err := request.Delete(path)
+	defer resp.Body.Close()
+
+	c.Assert(err, check.IsNil)
+	CheckRespStatus(c, resp, 204)
+
+	return err
+}
+
+
+// DelNetworkOk deletes the network and asserts success.
+func DelNetworkOk(c *check.C, cname string) {
+	resp, err := DelNetwork(c, cname)
+	c.Assert(err, check.IsNil)
+
+	CheckRespStatus(c, resp, 204)
+}
+
+// DelNetwork  deletes the network.
+func DelNetwork(c *check.C, cname string) (*http.Response, error) {
+	return request.Delete("/networks/" + cname)
+}