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 }