github.com/johnnyeven/libtools@v0.0.0-20191126065708-61829c1adf46/servicex/internal/deployment.go (about)

     1  package internal
     2  
     3  import (
     4  	"github.com/johnnyeven/libtools/docker"
     5  	"os"
     6  	"io/ioutil"
     7  	"gopkg.in/yaml.v2"
     8  	"os/exec"
     9  	"strings"
    10  	"github.com/fatih/color"
    11  	"github.com/sirupsen/logrus"
    12  	"github.com/johnnyeven/libtools/ptr"
    13  	"github.com/spf13/viper"
    14  	"path/filepath"
    15  )
    16  
    17  var (
    18  	EnvVarRef              = "PROJECT_REF"
    19  	EnvVarBuildRef         = "CI_COMMIT_SHA"
    20  	EnvVarBuildBranch      = "CI_COMMIT_REF"
    21  	EnvVarRancherEnv       = "RANCHER_ENVIRONMENT"
    22  	EnvVarRancherUrl       = "RANCHER_URL"
    23  	EnvVarRancherAccessKey = "RANCHER_ACCESS_KEY"
    24  	EnvVarRancherSecretKey = "RANCHER_SECRET_KEY"
    25  )
    26  
    27  var (
    28  	EnvValRancherUrl       = "http://rancher.profzone.net:38080"
    29  	EnvValRancherAccessKey = "744E0D8EF311C269FED1"
    30  	EnvValRancherSecretKey = "yBXzp7jdaaRqCtL92TJSRbekxzYr8x7Xr2r5rq11"
    31  )
    32  
    33  var tmpDockerfile = "Dockerfile"
    34  
    35  var DockerfileYmlOrders = []string{
    36  	"dockerfile.default.yml",
    37  	"dockerfile.yml",
    38  }
    39  
    40  var (
    41  	CIWorkingDirectory = "/drone/workspace"
    42  	CIGolangRootPath = "/go/src"
    43  	COGolangPackageName = "github.com/johnnyeven"
    44  )
    45  
    46  func CommandForDeploy(p *Project, deployEnv string) (command *exec.Cmd) {
    47  	SetEnv(EnvVarRancherEnv, deployEnv)
    48  	if viper.GetString("RANCHER_URL") == "" {
    49  		SetEnv(EnvVarRancherUrl, EnvValRancherUrl)
    50  	} else {
    51  		SetEnv(EnvVarRancherUrl, viper.GetString("RANCHER_URL"))
    52  	}
    53  	if viper.GetString("RANCHER_ACCESS_KEY") == "" {
    54  		SetEnv(EnvVarRancherAccessKey, EnvValRancherAccessKey)
    55  	} else {
    56  		SetEnv(EnvVarRancherAccessKey, viper.GetString("RANCHER_ACCESS_KEY"))
    57  	}
    58  	if viper.GetString("RANCHER_SECRET_KEY") == "" {
    59  		SetEnv(EnvVarRancherSecretKey, EnvValRancherSecretKey)
    60  	} else {
    61  		SetEnv(EnvVarRancherSecretKey, viper.GetString("RANCHER_SECRET_KEY"))
    62  	}
    63  	stackName := p.Group
    64  
    65  	if p.Feature != "" {
    66  		stackName = stackName + "--" + p.Feature
    67  	}
    68  
    69  	LoadEnv(deployEnv, p.Feature)
    70  
    71  	writeMemoryLimit(p.Name)
    72  
    73  	rancherUp := []string{
    74  		"rancher",
    75  		"up",
    76  		"-d",
    77  	}
    78  
    79  	_, err := os.Stat("/usr/local/bin/rancher-env.sh")
    80  	if err == nil {
    81  		rancherUp = append([]string{"rancher-env.sh"}, rancherUp...)
    82  	}
    83  
    84  	dockerComposeFiles := []string{
    85  		"docker-compose.initial.yml",
    86  		"docker-compose.default.yml",
    87  		"docker-compose.yml",
    88  	}
    89  
    90  	for _, dockerComposeFile := range dockerComposeFiles {
    91  		if isPathExist(dockerComposeFile) {
    92  			rancherUp = append(rancherUp, "-f", dockerComposeFile)
    93  		}
    94  	}
    95  
    96  	if p.Feature != "" {
    97  		p.Version.Prefix = p.Feature
    98  	}
    99  
   100  	rancherUp = append(rancherUp, "--stack", stackName, "--pull", "--force-upgrade", "--confirm-upgrade")
   101  
   102  	return p.Command(rancherUp...)
   103  }
   104  
   105  func CommandsForGoBuilder(p *Project) (commands []*exec.Cmd) {
   106  	/**
   107  	  - cp -r /drone/workspace/service-id /go/src/github.com/johnnyeven/service-id
   108        - cd /go/src/github.com/johnnyeven/service-id
   109        - go test
   110        - go build -v -o service-id
   111        - libtools swagger
   112        - cp ./service-id /drone/workspace/service-id/service-id
   113        - cp ./swagger.json /drone/workspace/service-id/swagger.json
   114  	 */
   115  
   116  	commands = append(commands, p.Command("cp", "-r", filepath.Join(CIWorkingDirectory, p.Name), filepath.Join(CIGolangRootPath, COGolangPackageName, p.Name)))
   117  	commands = append(commands, p.Command("go", "test"))
   118  	commands = append(commands, p.Command("go", "build", "-v", "-o", p.Name))
   119  	commands = append(commands, p.Command("libtools", "swagger"))
   120  
   121  	return
   122  }
   123  
   124  func CommandsForImageBuilder(p *Project, push bool) (commands []*exec.Cmd) {
   125  	dockerfile := &docker.Dockerfile{}
   126  
   127  	hasDockerfileYaml := false
   128  
   129  	for _, dockerfileYml := range DockerfileYmlOrders {
   130  		if isPathExist(dockerfileYml) {
   131  			hasDockerfileYaml = true
   132  			mayReadFileAndUnmarshal(dockerfileYml, dockerfile)
   133  		}
   134  	}
   135  
   136  	if dockerfile.Image == "" {
   137  		dockerfile.Image = "${PROFZONE_DOCKER_REGISTRY}/${PROJECT_GROUP}/${PROJECT_NAME}:${PROJECT_VERSION}"
   138  	}
   139  
   140  	if hasDockerfileYaml {
   141  		p.SetEnviron()
   142  		dockerfile = dockerfile.AddEnv(EnvVarRef, p.Version.String()+"-"+os.Getenv(EnvVarBuildRef))
   143  
   144  		dockerfile.AddEnv("PROJECT_GROUP", p.Group)
   145  		dockerfile.AddEnv("PROJECT_NAME", p.Name)
   146  		dockerfile.AddEnv("PROJECT_FEATURE", p.Feature)
   147  
   148  		ioutil.WriteFile(tmpDockerfile, []byte(dockerfile.String()), os.ModePerm)
   149  	}
   150  
   151  	if p.Feature != "" {
   152  		p.Version.Prefix = p.Feature
   153  	}
   154  
   155  	commands = append(commands, p.Command("docker", "build", "-f", tmpDockerfile, "-t", dockerfile.Image, "."))
   156  	if push {
   157  		commands = append(commands, p.Command("docker", "push", dockerfile.Image))
   158  	}
   159  	return
   160  }
   161  
   162  func writeMemoryLimit(serviceName string) {
   163  	compose := docker.NewDockerCompose()
   164  
   165  	s := docker.NewService("busybox:latest")
   166  	s.MemLimit = ptr.Int64(1073741824)
   167  
   168  	compose = compose.AddService(serviceName, s)
   169  	data, _ := yaml.Marshal(compose)
   170  
   171  	ioutil.WriteFile("docker-compose.initial.yml", data, os.ModePerm)
   172  }
   173  
   174  func isPathExist(path string) bool {
   175  	f, _ := os.Stat(path)
   176  	return f != nil
   177  }
   178  
   179  func LoadEnv(envName string, feature string) {
   180  	loadEnvFromFiles("default", feature)
   181  	if envName != "" {
   182  		loadEnvFromFiles(envName, feature)
   183  	}
   184  }
   185  
   186  func loadEnvFromFiles(envName string, feature string) {
   187  	loadEnvFromFile(envName)
   188  	if feature != "" {
   189  		loadEnvFromFile(envName + "-" + feature)
   190  	}
   191  }
   192  
   193  func loadEnvFromFile(envName string) {
   194  	filename := "config/" + strings.ToLower(envName) + ".yml"
   195  	logrus.Infof("try to load env vars from %s ...\n", color.GreenString(filename))
   196  	envFileContent, err := ioutil.ReadFile(filename)
   197  	if err == nil {
   198  		var envVars map[string]string
   199  		err := yaml.Unmarshal([]byte(envFileContent), &envVars)
   200  		if err != nil {
   201  			panic(err)
   202  		}
   203  		for key, value := range envVars {
   204  			SetEnv(key, value)
   205  		}
   206  	}
   207  }
   208  
   209  func mayReadFileAndUnmarshal(file string, v interface{}) {
   210  	bytes, errForRead := ioutil.ReadFile(file)
   211  	if errForRead != nil {
   212  		panic(errForRead)
   213  	}
   214  	err := yaml.Unmarshal(bytes, v)
   215  	if err != nil {
   216  		panic(err)
   217  	}
   218  }