2021-08-02 04:51:58 +00:00
|
|
|
package config
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"io/ioutil"
|
|
|
|
"os"
|
|
|
|
"path"
|
2023-01-31 15:06:35 +00:00
|
|
|
"strconv"
|
2021-08-02 04:51:58 +00:00
|
|
|
"strings"
|
|
|
|
|
2022-12-16 18:20:51 +00:00
|
|
|
"github.com/schollz/progressbar/v3"
|
|
|
|
|
2023-01-31 15:09:09 +00:00
|
|
|
"coopcloud.tech/abra/pkg/client"
|
2021-12-28 00:24:23 +00:00
|
|
|
"coopcloud.tech/abra/pkg/formatter"
|
2021-10-21 17:35:13 +00:00
|
|
|
"coopcloud.tech/abra/pkg/upstream/convert"
|
|
|
|
loader "coopcloud.tech/abra/pkg/upstream/stack"
|
|
|
|
stack "coopcloud.tech/abra/pkg/upstream/stack"
|
2021-08-06 17:38:06 +00:00
|
|
|
composetypes "github.com/docker/cli/cli/compose/types"
|
2022-03-27 10:40:05 +00:00
|
|
|
"github.com/docker/docker/api/types/filters"
|
2021-09-10 22:54:02 +00:00
|
|
|
"github.com/sirupsen/logrus"
|
2021-08-02 04:51:58 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// Type aliases to make code hints easier to understand
|
2021-08-02 07:02:18 +00:00
|
|
|
|
|
|
|
// AppEnv is a map of the values in an apps env config
|
2021-08-02 04:51:58 +00:00
|
|
|
type AppEnv = map[string]string
|
2021-08-02 07:02:18 +00:00
|
|
|
|
|
|
|
// AppName is AppName
|
2021-08-02 04:51:58 +00:00
|
|
|
type AppName = string
|
|
|
|
|
2021-08-02 07:02:18 +00:00
|
|
|
// AppFile represents app env files on disk without reading the contents
|
2021-08-02 04:51:58 +00:00
|
|
|
type AppFile struct {
|
|
|
|
Path string
|
|
|
|
Server string
|
|
|
|
}
|
|
|
|
|
2021-08-02 07:02:18 +00:00
|
|
|
// AppFiles is a slice of appfiles
|
2021-08-02 04:51:58 +00:00
|
|
|
type AppFiles map[AppName]AppFile
|
|
|
|
|
2021-08-02 07:02:18 +00:00
|
|
|
// App reprents an app with its env file read into memory
|
2021-08-02 04:51:58 +00:00
|
|
|
type App struct {
|
|
|
|
Name AppName
|
2022-01-25 11:37:13 +00:00
|
|
|
Recipe string
|
2021-08-02 04:51:58 +00:00
|
|
|
Domain string
|
|
|
|
Env AppEnv
|
2021-09-05 21:17:35 +00:00
|
|
|
Server string
|
|
|
|
Path string
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
|
2023-01-22 17:12:11 +00:00
|
|
|
// StackName gets whatever the docker safe (uses the right delimiting
|
|
|
|
// character, e.g. "_") stack name is for the app. In general, you don't want
|
|
|
|
// to use this to show anything to end-users, you want use a.Name instead.
|
2021-08-02 04:51:58 +00:00
|
|
|
func (a App) StackName() string {
|
2021-10-12 06:55:42 +00:00
|
|
|
if _, exists := a.Env["STACK_NAME"]; exists {
|
2021-10-11 23:14:14 +00:00
|
|
|
return a.Env["STACK_NAME"]
|
|
|
|
}
|
2022-01-01 16:22:19 +00:00
|
|
|
|
2021-10-12 07:03:48 +00:00
|
|
|
stackName := SanitiseAppName(a.Name)
|
2022-01-27 08:56:22 +00:00
|
|
|
|
|
|
|
if len(stackName) > 45 {
|
|
|
|
logrus.Debugf("trimming %s to %s to avoid runtime limits", stackName, stackName[:45])
|
|
|
|
stackName = stackName[:45]
|
|
|
|
}
|
|
|
|
|
2021-10-12 07:03:48 +00:00
|
|
|
a.Env["STACK_NAME"] = stackName
|
2022-01-01 16:22:19 +00:00
|
|
|
|
2021-10-12 07:03:48 +00:00
|
|
|
return stackName
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
|
2022-03-30 14:11:52 +00:00
|
|
|
// Filters retrieves exact app filters for querying the container runtime. Due
|
|
|
|
// to upstream issues, filtering works different depending on what you're
|
|
|
|
// querying. So, for example, secrets don't work with regex! The caller needs
|
|
|
|
// to implement their own validation that the right secrets are matched. In
|
|
|
|
// order to handle these cases, we provide the `appendServiceNames` /
|
|
|
|
// `exactMatch` modifiers.
|
|
|
|
func (a App) Filters(appendServiceNames, exactMatch bool) (filters.Args, error) {
|
2022-03-27 10:40:05 +00:00
|
|
|
filters := filters.NewArgs()
|
|
|
|
|
|
|
|
composeFiles, err := GetAppComposeFiles(a.Recipe, a.Env)
|
|
|
|
if err != nil {
|
|
|
|
return filters, err
|
|
|
|
}
|
|
|
|
|
|
|
|
opts := stack.Deploy{Composefiles: composeFiles}
|
|
|
|
compose, err := GetAppComposeConfig(a.Recipe, opts, a.Env)
|
|
|
|
if err != nil {
|
|
|
|
return filters, err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, service := range compose.Services {
|
2022-03-30 14:11:52 +00:00
|
|
|
var filter string
|
|
|
|
|
|
|
|
if appendServiceNames {
|
|
|
|
if exactMatch {
|
|
|
|
filter = fmt.Sprintf("^%s_%s", a.StackName(), service.Name)
|
|
|
|
} else {
|
|
|
|
filter = fmt.Sprintf("%s_%s", a.StackName(), service.Name)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if exactMatch {
|
|
|
|
filter = fmt.Sprintf("^%s", a.StackName())
|
|
|
|
} else {
|
|
|
|
filter = fmt.Sprintf("%s", a.StackName())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-27 10:40:05 +00:00
|
|
|
filters.Add("name", filter)
|
|
|
|
}
|
|
|
|
|
|
|
|
return filters, nil
|
|
|
|
}
|
|
|
|
|
2021-08-02 07:02:18 +00:00
|
|
|
// ByServer sort a slice of Apps
|
2021-08-02 04:51:58 +00:00
|
|
|
type ByServer []App
|
|
|
|
|
|
|
|
func (a ByServer) Len() int { return len(a) }
|
|
|
|
func (a ByServer) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
|
|
func (a ByServer) Less(i, j int) bool {
|
2021-09-05 21:17:35 +00:00
|
|
|
return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
|
2022-01-25 11:37:13 +00:00
|
|
|
// ByServerAndRecipe sort a slice of Apps
|
|
|
|
type ByServerAndRecipe []App
|
2021-08-02 04:51:58 +00:00
|
|
|
|
2022-01-25 11:37:13 +00:00
|
|
|
func (a ByServerAndRecipe) Len() int { return len(a) }
|
|
|
|
func (a ByServerAndRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
|
|
func (a ByServerAndRecipe) Less(i, j int) bool {
|
2021-09-05 21:17:35 +00:00
|
|
|
if a[i].Server == a[j].Server {
|
2022-01-25 11:37:13 +00:00
|
|
|
return strings.ToLower(a[i].Recipe) < strings.ToLower(a[j].Recipe)
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2021-09-05 21:17:35 +00:00
|
|
|
return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
|
2022-01-25 11:37:13 +00:00
|
|
|
// ByRecipe sort a slice of Apps
|
|
|
|
type ByRecipe []App
|
2021-08-02 04:51:58 +00:00
|
|
|
|
2022-01-25 11:37:13 +00:00
|
|
|
func (a ByRecipe) Len() int { return len(a) }
|
|
|
|
func (a ByRecipe) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
|
|
func (a ByRecipe) Less(i, j int) bool {
|
|
|
|
return strings.ToLower(a[i].Recipe) < strings.ToLower(a[j].Recipe)
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
|
2021-08-02 07:02:18 +00:00
|
|
|
// ByName sort a slice of Apps
|
2021-08-02 04:51:58 +00:00
|
|
|
type ByName []App
|
|
|
|
|
|
|
|
func (a ByName) Len() int { return len(a) }
|
|
|
|
func (a ByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
|
|
func (a ByName) Less(i, j int) bool {
|
|
|
|
return strings.ToLower(a[i].Name) < strings.ToLower(a[j].Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
func readAppEnvFile(appFile AppFile, name AppName) (App, error) {
|
|
|
|
env, err := ReadEnv(appFile.Path)
|
|
|
|
if err != nil {
|
2021-12-25 01:03:09 +00:00
|
|
|
return App{}, fmt.Errorf("env file for %s couldn't be read: %s", name, err.Error())
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-12-25 01:03:09 +00:00
|
|
|
logrus.Debugf("read env %s from %s", env, appFile.Path)
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
app, err := newApp(env, name, appFile)
|
|
|
|
if err != nil {
|
2021-12-25 01:03:09 +00:00
|
|
|
return App{}, fmt.Errorf("env file for %s has issues: %s", name, err.Error())
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
return app, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// newApp creates new App object
|
|
|
|
func newApp(env AppEnv, name string, appFile AppFile) (App, error) {
|
|
|
|
domain := env["DOMAIN"]
|
2021-12-19 21:45:08 +00:00
|
|
|
|
2022-01-25 11:37:13 +00:00
|
|
|
recipe, exists := env["RECIPE"]
|
2021-12-19 21:45:08 +00:00
|
|
|
if !exists {
|
2022-03-11 18:37:50 +00:00
|
|
|
recipe, exists = env["TYPE"]
|
|
|
|
if !exists {
|
2023-02-12 15:37:02 +00:00
|
|
|
return App{}, fmt.Errorf("%s is missing the TYPE env var?", name)
|
2022-03-11 18:37:50 +00:00
|
|
|
}
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
return App{
|
|
|
|
Name: name,
|
|
|
|
Domain: domain,
|
2022-01-25 11:37:13 +00:00
|
|
|
Recipe: recipe,
|
2021-08-02 04:51:58 +00:00
|
|
|
Env: env,
|
2021-09-05 21:17:35 +00:00
|
|
|
Server: appFile.Server,
|
|
|
|
Path: appFile.Path,
|
2021-08-02 04:51:58 +00:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:54:22 +00:00
|
|
|
// LoadAppFiles gets all app files for a given set of servers or all servers.
|
2021-08-02 04:51:58 +00:00
|
|
|
func LoadAppFiles(servers ...string) (AppFiles, error) {
|
|
|
|
appFiles := make(AppFiles)
|
|
|
|
if len(servers) == 1 {
|
|
|
|
if servers[0] == "" {
|
|
|
|
// Empty servers flag, one string will always be passed
|
|
|
|
var err error
|
2021-12-25 13:04:07 +00:00
|
|
|
servers, err = GetAllFoldersInDirectory(SERVERS_DIR)
|
2021-08-02 04:51:58 +00:00
|
|
|
if err != nil {
|
2023-01-22 23:54:22 +00:00
|
|
|
return appFiles, err
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-12-19 23:49:36 +00:00
|
|
|
logrus.Debugf("collecting metadata from %v servers: %s", len(servers), strings.Join(servers, ", "))
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
for _, server := range servers {
|
2021-12-25 13:04:07 +00:00
|
|
|
serverDir := path.Join(SERVERS_DIR, server)
|
2023-01-23 12:56:27 +00:00
|
|
|
files, err := GetAllFilesInDirectory(serverDir)
|
2021-08-02 04:51:58 +00:00
|
|
|
if err != nil {
|
2023-01-22 23:54:22 +00:00
|
|
|
return appFiles, fmt.Errorf("server %s doesn't exist? Run \"abra server ls\" to check", server)
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2023-01-22 23:54:22 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
for _, file := range files {
|
|
|
|
appName := strings.TrimSuffix(file.Name(), ".env")
|
2021-12-25 13:04:07 +00:00
|
|
|
appFilePath := path.Join(SERVERS_DIR, server, file.Name())
|
2021-08-02 04:51:58 +00:00
|
|
|
appFiles[appName] = AppFile{
|
|
|
|
Path: appFilePath,
|
|
|
|
Server: server,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-22 23:54:22 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
return appFiles, nil
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:54:22 +00:00
|
|
|
// GetApp loads an apps settings, reading it from file, in preparation to use
|
|
|
|
// it. It should only be used when ready to use the env file to keep IO
|
|
|
|
// operations down.
|
2021-08-02 04:51:58 +00:00
|
|
|
func GetApp(apps AppFiles, name AppName) (App, error) {
|
|
|
|
appFile, exists := apps[name]
|
|
|
|
if !exists {
|
2021-12-19 23:49:36 +00:00
|
|
|
return App{}, fmt.Errorf("cannot find app with name %s", name)
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
app, err := readAppEnvFile(appFile, name)
|
|
|
|
if err != nil {
|
|
|
|
return App{}, err
|
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
return app, nil
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:54:22 +00:00
|
|
|
// GetApps returns a slice of Apps with their env files read from a given
|
|
|
|
// slice of AppFiles.
|
|
|
|
func GetApps(appFiles AppFiles, recipeFilter string) ([]App, error) {
|
2021-08-02 04:51:58 +00:00
|
|
|
var apps []App
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
for name := range appFiles {
|
|
|
|
app, err := GetApp(appFiles, name)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2023-01-22 23:54:22 +00:00
|
|
|
|
|
|
|
if recipeFilter != "" {
|
|
|
|
if app.Recipe == recipeFilter {
|
|
|
|
apps = append(apps, app)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
apps = append(apps, app)
|
|
|
|
}
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
return apps, nil
|
|
|
|
}
|
|
|
|
|
2021-09-16 07:10:05 +00:00
|
|
|
// GetAppServiceNames retrieves a list of app service names.
|
|
|
|
func GetAppServiceNames(appName string) ([]string, error) {
|
|
|
|
var serviceNames []string
|
|
|
|
|
|
|
|
appFiles, err := LoadAppFiles("")
|
|
|
|
if err != nil {
|
|
|
|
return serviceNames, err
|
|
|
|
}
|
|
|
|
|
|
|
|
app, err := GetApp(appFiles, appName)
|
|
|
|
if err != nil {
|
|
|
|
return serviceNames, err
|
|
|
|
}
|
|
|
|
|
2022-01-25 11:37:13 +00:00
|
|
|
composeFiles, err := GetAppComposeFiles(app.Recipe, app.Env)
|
2021-09-16 07:10:05 +00:00
|
|
|
if err != nil {
|
|
|
|
return serviceNames, err
|
|
|
|
}
|
|
|
|
|
|
|
|
opts := stack.Deploy{Composefiles: composeFiles}
|
2022-01-25 11:37:13 +00:00
|
|
|
compose, err := GetAppComposeConfig(app.Recipe, opts, app.Env)
|
2021-09-16 07:10:05 +00:00
|
|
|
if err != nil {
|
|
|
|
return serviceNames, err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, service := range compose.Services {
|
|
|
|
serviceNames = append(serviceNames, service.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
return serviceNames, nil
|
|
|
|
}
|
|
|
|
|
2021-09-10 22:54:02 +00:00
|
|
|
// GetAppNames retrieves a list of app names.
|
2021-09-08 11:43:55 +00:00
|
|
|
func GetAppNames() ([]string, error) {
|
2021-09-16 07:09:51 +00:00
|
|
|
var appNames []string
|
|
|
|
|
2021-09-07 14:57:39 +00:00
|
|
|
appFiles, err := LoadAppFiles("")
|
|
|
|
if err != nil {
|
2021-09-16 07:09:51 +00:00
|
|
|
return appNames, err
|
2021-09-07 14:57:39 +00:00
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2023-01-22 23:54:22 +00:00
|
|
|
apps, err := GetApps(appFiles, "")
|
2021-09-07 14:57:39 +00:00
|
|
|
if err != nil {
|
2021-09-16 07:09:51 +00:00
|
|
|
return appNames, err
|
2021-09-07 14:57:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, app := range apps {
|
|
|
|
appNames = append(appNames, app.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
return appNames, nil
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:54:22 +00:00
|
|
|
// TemplateAppEnvSample copies the example env file for the app into the users
|
|
|
|
// env files.
|
2021-12-25 13:04:07 +00:00
|
|
|
func TemplateAppEnvSample(recipeName, appName, server, domain string) error {
|
|
|
|
envSamplePath := path.Join(RECIPES_DIR, recipeName, ".env.sample")
|
2021-08-02 04:51:58 +00:00
|
|
|
envSample, err := ioutil.ReadFile(envSamplePath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
appEnvPath := path.Join(ABRA_DIR, "servers", server, fmt.Sprintf("%s.env", appName))
|
2021-12-22 19:08:15 +00:00
|
|
|
if _, err := os.Stat(appEnvPath); os.IsExist(err) {
|
2021-08-02 04:51:58 +00:00
|
|
|
return fmt.Errorf("%s already exists?", appEnvPath)
|
|
|
|
}
|
|
|
|
|
2021-12-22 19:08:15 +00:00
|
|
|
err = ioutil.WriteFile(appEnvPath, envSample, 0664)
|
2021-08-02 04:51:58 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-11-14 15:49:00 +00:00
|
|
|
read, err := ioutil.ReadFile(appEnvPath)
|
2021-12-26 03:38:34 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-11-14 15:49:00 +00:00
|
|
|
newContents := strings.Replace(string(read), recipeName+".example.com", domain, -1)
|
2021-12-26 03:38:34 +00:00
|
|
|
|
2022-11-14 15:49:00 +00:00
|
|
|
err = ioutil.WriteFile(appEnvPath, []byte(newContents), 0)
|
|
|
|
if err != nil {
|
2022-11-14 17:58:40 +00:00
|
|
|
return err
|
2021-12-26 03:38:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
logrus.Debugf("copied & templated %s to %s", envSamplePath, appEnvPath)
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:54:22 +00:00
|
|
|
// SanitiseAppName makes a app name usable with Docker by replacing illegal
|
|
|
|
// characters.
|
2021-08-02 04:51:58 +00:00
|
|
|
func SanitiseAppName(name string) string {
|
|
|
|
return strings.ReplaceAll(name, ".", "_")
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:54:22 +00:00
|
|
|
// GetAppStatuses queries servers to check the deployment status of given apps.
|
|
|
|
func GetAppStatuses(apps []App, MachineReadable bool) (map[string]map[string]string, error) {
|
2021-10-08 07:51:47 +00:00
|
|
|
statuses := make(map[string]map[string]string)
|
2021-09-16 07:26:12 +00:00
|
|
|
|
2021-09-20 20:43:30 +00:00
|
|
|
servers := make(map[string]struct{})
|
2023-01-22 23:54:22 +00:00
|
|
|
for _, app := range apps {
|
|
|
|
if _, ok := servers[app.Server]; !ok {
|
|
|
|
servers[app.Server] = struct{}{}
|
2021-09-20 20:43:30 +00:00
|
|
|
}
|
2021-09-16 07:26:12 +00:00
|
|
|
}
|
|
|
|
|
2023-01-31 15:09:09 +00:00
|
|
|
var bar *progressbar.ProgressBar
|
2022-12-16 18:20:51 +00:00
|
|
|
if !MachineReadable {
|
|
|
|
bar = formatter.CreateProgressbar(len(servers), "querying remote servers...")
|
|
|
|
}
|
2023-01-22 23:54:22 +00:00
|
|
|
|
2021-08-03 07:49:16 +00:00
|
|
|
ch := make(chan stack.StackStatus, len(servers))
|
2021-09-20 20:43:30 +00:00
|
|
|
for server := range servers {
|
2023-01-31 15:09:09 +00:00
|
|
|
cl, err := client.New(server)
|
|
|
|
if err != nil {
|
|
|
|
return statuses, err
|
|
|
|
}
|
|
|
|
|
2021-09-20 20:43:30 +00:00
|
|
|
go func(s string) {
|
2023-01-31 15:09:09 +00:00
|
|
|
ch <- stack.GetAllDeployedServices(cl, s)
|
2022-12-16 18:20:51 +00:00
|
|
|
if !MachineReadable {
|
|
|
|
bar.Add(1)
|
|
|
|
}
|
2021-09-20 20:43:30 +00:00
|
|
|
}(server)
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for range servers {
|
|
|
|
status := <-ch
|
2023-01-31 15:09:09 +00:00
|
|
|
if status.Err != nil {
|
|
|
|
return statuses, status.Err
|
|
|
|
}
|
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
for _, service := range status.Services {
|
2021-10-08 08:50:48 +00:00
|
|
|
result := make(map[string]string)
|
2021-08-03 07:49:16 +00:00
|
|
|
name := service.Spec.Labels[convert.LabelNamespace]
|
2021-10-08 07:51:47 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
if _, ok := statuses[name]; !ok {
|
2021-10-08 07:51:47 +00:00
|
|
|
result["status"] = "deployed"
|
|
|
|
}
|
|
|
|
|
2023-03-01 11:17:23 +00:00
|
|
|
labelKey := fmt.Sprintf("coop-cloud.%s.chaos", name)
|
|
|
|
chaos, ok := service.Spec.Labels[labelKey]
|
|
|
|
if ok {
|
|
|
|
result["chaos"] = chaos
|
|
|
|
}
|
|
|
|
|
2023-03-07 11:27:02 +00:00
|
|
|
labelKey = fmt.Sprintf("coop-cloud.%s.chaos-version", name)
|
2023-03-01 11:17:23 +00:00
|
|
|
if chaosVersion, ok := service.Spec.Labels[labelKey]; ok {
|
|
|
|
result["chaosVersion"] = chaosVersion
|
|
|
|
}
|
|
|
|
|
2023-03-07 11:31:44 +00:00
|
|
|
labelKey = fmt.Sprintf("coop-cloud.%s.auto-update", name)
|
2023-03-01 11:26:28 +00:00
|
|
|
if autoUpdate, ok := service.Spec.Labels[labelKey]; ok {
|
|
|
|
result["autoUpdate"] = autoUpdate
|
|
|
|
} else {
|
|
|
|
result["autoUpdate"] = "false"
|
|
|
|
}
|
|
|
|
|
2023-03-01 11:17:23 +00:00
|
|
|
labelKey = fmt.Sprintf("coop-cloud.%s.version", name)
|
2021-10-08 07:51:47 +00:00
|
|
|
if version, ok := service.Spec.Labels[labelKey]; ok {
|
|
|
|
result["version"] = version
|
2021-10-08 08:50:48 +00:00
|
|
|
} else {
|
|
|
|
continue
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
2021-10-08 07:51:47 +00:00
|
|
|
|
|
|
|
statuses[name] = result
|
2021-08-02 04:51:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-19 23:49:36 +00:00
|
|
|
logrus.Debugf("retrieved app statuses: %s", statuses)
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-02 04:51:58 +00:00
|
|
|
return statuses, nil
|
|
|
|
}
|
2021-08-06 17:38:06 +00:00
|
|
|
|
2021-09-04 20:02:49 +00:00
|
|
|
// GetAppComposeFiles gets the list of compose files for an app which should be
|
|
|
|
// merged into a composetypes.Config while respecting the COMPOSE_FILE env var.
|
|
|
|
func GetAppComposeFiles(recipe string, appEnv AppEnv) ([]string, error) {
|
2021-10-12 08:25:37 +00:00
|
|
|
var composeFiles []string
|
|
|
|
|
2021-09-04 20:02:49 +00:00
|
|
|
if _, ok := appEnv["COMPOSE_FILE"]; !ok {
|
2021-10-12 08:25:37 +00:00
|
|
|
logrus.Debug("no COMPOSE_FILE detected, loading compose.yml")
|
2021-12-25 13:04:07 +00:00
|
|
|
path := fmt.Sprintf("%s/%s/compose.yml", RECIPES_DIR, recipe)
|
2021-10-12 08:34:10 +00:00
|
|
|
composeFiles = append(composeFiles, path)
|
2021-09-04 20:02:49 +00:00
|
|
|
return composeFiles, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
composeFileEnvVar := appEnv["COMPOSE_FILE"]
|
2021-09-16 07:45:02 +00:00
|
|
|
envVars := strings.Split(composeFileEnvVar, ":")
|
2021-12-19 23:49:36 +00:00
|
|
|
logrus.Debugf("COMPOSE_FILE detected (%s), loading %s", composeFileEnvVar, strings.Join(envVars, ", "))
|
2021-09-04 20:02:49 +00:00
|
|
|
for _, file := range strings.Split(composeFileEnvVar, ":") {
|
2021-12-25 13:04:07 +00:00
|
|
|
path := fmt.Sprintf("%s/%s/%s", RECIPES_DIR, recipe, file)
|
2021-09-04 20:02:49 +00:00
|
|
|
composeFiles = append(composeFiles, path)
|
2021-08-06 17:38:06 +00:00
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-12-19 23:49:36 +00:00
|
|
|
logrus.Debugf("retrieved %s configs for %s", strings.Join(composeFiles, ", "), recipe)
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-09-04 20:02:49 +00:00
|
|
|
return composeFiles, nil
|
|
|
|
}
|
2021-08-06 17:38:06 +00:00
|
|
|
|
2021-09-04 20:02:49 +00:00
|
|
|
// GetAppComposeConfig retrieves a compose specification for a recipe. This
|
|
|
|
// specification is the result of a merge of all the compose.**.yml files in
|
|
|
|
// the recipe repository.
|
|
|
|
func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv AppEnv) (*composetypes.Config, error) {
|
2021-09-01 13:01:20 +00:00
|
|
|
compose, err := loader.LoadComposefile(opts, appEnv)
|
2021-08-06 17:38:06 +00:00
|
|
|
if err != nil {
|
|
|
|
return &composetypes.Config{}, err
|
|
|
|
}
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-12-19 23:49:36 +00:00
|
|
|
logrus.Debugf("retrieved %s for %s", compose.Filename, recipe)
|
2021-09-10 22:54:02 +00:00
|
|
|
|
2021-08-06 17:38:06 +00:00
|
|
|
return compose, nil
|
|
|
|
}
|
2023-01-31 14:13:43 +00:00
|
|
|
|
|
|
|
// ExposeAllEnv exposes all env variables to the app container
|
|
|
|
func ExposeAllEnv(stackName string, compose *composetypes.Config, appEnv AppEnv) {
|
|
|
|
for _, service := range compose.Services {
|
|
|
|
if service.Name == "app" {
|
|
|
|
logrus.Debugf("Add the following environment to the app service config of %s:", stackName)
|
|
|
|
for k, v := range appEnv {
|
|
|
|
_, exists := service.Environment[k]
|
|
|
|
if !exists {
|
|
|
|
value := v
|
|
|
|
service.Environment[k] = &value
|
|
|
|
logrus.Debugf("Add Key: %s Value: %s to %s", k, value, stackName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-31 14:35:43 +00:00
|
|
|
|
|
|
|
// SetRecipeLabel adds the label 'coop-cloud.${STACK_NAME}.recipe=${RECIPE}' to the app container
|
|
|
|
// to signal which recipe is connected to the deployed app
|
|
|
|
func SetRecipeLabel(compose *composetypes.Config, stackName string, recipe string) {
|
|
|
|
for _, service := range compose.Services {
|
|
|
|
if service.Name == "app" {
|
|
|
|
logrus.Debugf("set recipe label 'coop-cloud.%s.recipe' to %s for %s", stackName, recipe, stackName)
|
|
|
|
labelKey := fmt.Sprintf("coop-cloud.%s.recipe", stackName)
|
|
|
|
service.Deploy.Labels[labelKey] = recipe
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-31 15:06:35 +00:00
|
|
|
|
|
|
|
// SetChaosLabel adds the label 'coop-cloud.${STACK_NAME}.chaos=true/false' to the app container
|
|
|
|
// to signal if the app is deployed in chaos mode
|
|
|
|
func SetChaosLabel(compose *composetypes.Config, stackName string, chaos bool) {
|
|
|
|
for _, service := range compose.Services {
|
|
|
|
if service.Name == "app" {
|
2023-02-08 10:11:39 +00:00
|
|
|
logrus.Debugf("set label 'coop-cloud.%s.chaos' to %v for %s", stackName, chaos, stackName)
|
2023-01-31 15:06:35 +00:00
|
|
|
labelKey := fmt.Sprintf("coop-cloud.%s.chaos", stackName)
|
|
|
|
service.Deploy.Labels[labelKey] = strconv.FormatBool(chaos)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-31 12:33:41 +00:00
|
|
|
|
2023-03-07 11:27:02 +00:00
|
|
|
// SetChaosVersionLabel adds the label 'coop-cloud.${STACK_NAME}.chaos-version=$(GIT_COMMIT)' to the app container
|
2023-03-01 11:16:17 +00:00
|
|
|
func SetChaosVersionLabel(compose *composetypes.Config, stackName string, chaosVersion string) {
|
|
|
|
for _, service := range compose.Services {
|
|
|
|
if service.Name == "app" {
|
2023-03-07 11:27:02 +00:00
|
|
|
logrus.Debugf("set label 'coop-cloud.%s.chaos-version' to %v for %s", stackName, chaosVersion, stackName)
|
|
|
|
labelKey := fmt.Sprintf("coop-cloud.%s.chaos-version", stackName)
|
2023-03-01 11:16:17 +00:00
|
|
|
service.Deploy.Labels[labelKey] = chaosVersion
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-31 15:15:11 +00:00
|
|
|
// SetUpdateLabel adds env ENABLE_AUTO_UPDATE as label to enable/disable the
|
|
|
|
// auto update process for this app. The default if this variable is not set is to disable
|
|
|
|
// the auto update process.
|
2023-01-31 12:33:41 +00:00
|
|
|
func SetUpdateLabel(compose *composetypes.Config, stackName string, appEnv AppEnv) {
|
|
|
|
for _, service := range compose.Services {
|
|
|
|
if service.Name == "app" {
|
|
|
|
enable_auto_update, exists := appEnv["ENABLE_AUTO_UPDATE"]
|
|
|
|
if !exists {
|
|
|
|
enable_auto_update = "false"
|
|
|
|
}
|
2023-03-07 11:31:44 +00:00
|
|
|
logrus.Debugf("set label 'coop-cloud.%s.auto-update' to %s for %s", stackName, enable_auto_update, stackName)
|
|
|
|
labelKey := fmt.Sprintf("coop-cloud.%s.auto-update", stackName)
|
2023-01-31 12:33:41 +00:00
|
|
|
service.Deploy.Labels[labelKey] = enable_auto_update
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|