You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
125 lines
3.0 KiB
125 lines
3.0 KiB
package lich
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/md5"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"github.com/bilibili/kratos/pkg/log"
|
|
)
|
|
|
|
var (
|
|
retry int
|
|
noDown bool
|
|
yamlPath string
|
|
pathHash string
|
|
services map[string]*Container
|
|
)
|
|
|
|
func init() {
|
|
flag.StringVar(&yamlPath, "f", "docker-compose.yaml", "composer yaml path.")
|
|
flag.BoolVar(&noDown, "nodown", false, "containers are not recycled.")
|
|
}
|
|
|
|
func runCompose(args ...string) (output []byte, err error) {
|
|
if _, err = os.Stat(yamlPath); os.IsNotExist(err) {
|
|
log.Error("os.Stat(%s) composer yaml is not exist!", yamlPath)
|
|
return
|
|
}
|
|
if yamlPath, err = filepath.Abs(yamlPath); err != nil {
|
|
log.Error("filepath.Abs(%s) error(%v)", yamlPath, err)
|
|
return
|
|
}
|
|
pathHash = fmt.Sprintf("%x", md5.Sum([]byte(yamlPath)))[:9]
|
|
args = append([]string{"-f", yamlPath, "-p", pathHash}, args...)
|
|
if output, err = exec.Command("docker-compose", args...).CombinedOutput(); err != nil {
|
|
log.Error("exec.Command(docker-compose) args(%v) stdout(%s) error(%v)", args, string(output), err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// Setup setup UT related environment dependence for everything.
|
|
func Setup() (err error) {
|
|
if _, err = runCompose("up", "-d"); err != nil {
|
|
return
|
|
}
|
|
defer func() {
|
|
if err != err {
|
|
go Teardown()
|
|
}
|
|
}()
|
|
if _, err = getServices(); err != nil {
|
|
return
|
|
}
|
|
_, err = checkServices()
|
|
return
|
|
}
|
|
|
|
// Teardown unsetup all environment dependence.
|
|
func Teardown() (err error) {
|
|
if !noDown {
|
|
_, err = runCompose("down")
|
|
}
|
|
return
|
|
}
|
|
|
|
func getServices() (output []byte, err error) {
|
|
if output, err = runCompose("config", "--services"); err != nil {
|
|
return
|
|
}
|
|
services = make(map[string]*Container)
|
|
output = bytes.TrimSpace(output)
|
|
for _, svr := range bytes.Split(output, []byte("\n")) {
|
|
if output, err = runCompose("ps", "-a", "-q", string(svr)); err != nil {
|
|
return
|
|
}
|
|
var (
|
|
id = string(bytes.TrimSpace(output))
|
|
args = []string{"inspect", id, "--format", "'{{json .}}'"}
|
|
)
|
|
if output, err = exec.Command("docker", args...).CombinedOutput(); err != nil {
|
|
log.Error("exec.Command(docker) args(%v) stdout(%s) error(%v)", args, string(output), err)
|
|
return
|
|
}
|
|
if output = bytes.TrimSpace(output); bytes.Equal(output, []byte("")) {
|
|
err = fmt.Errorf("service: %s | container: %s fails to launch", svr, id)
|
|
log.Error("exec.Command(docker) args(%v) error(%v)", args, err)
|
|
return
|
|
}
|
|
var c = &Container{}
|
|
if err = json.Unmarshal(bytes.Trim(output, "'"), c); err != nil {
|
|
log.Error("json.Unmarshal(%s) error(%v)", string(output), err)
|
|
return
|
|
}
|
|
services[string(svr)] = c
|
|
}
|
|
return
|
|
}
|
|
|
|
func checkServices() (output []byte, err error) {
|
|
defer func() {
|
|
if err != nil && retry < 4 {
|
|
retry++
|
|
getServices()
|
|
time.Sleep(time.Second * 5)
|
|
output, err = checkServices()
|
|
return
|
|
}
|
|
retry = 0
|
|
}()
|
|
for svr, c := range services {
|
|
if err = c.Healthcheck(); err != nil {
|
|
log.Error("healthcheck(%s) error(%v) retrying %d times...", svr, err, 5-retry)
|
|
return
|
|
}
|
|
// TODO About container check and more...
|
|
}
|
|
return
|
|
}
|
|
|