abra/pkg/config/app.go

package config

import (
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"strings"

	"coopcloud.tech/abra/cli/formatter"
	"coopcloud.tech/abra/pkg/client/convert"
	loader "coopcloud.tech/abra/pkg/client/stack"
	stack "coopcloud.tech/abra/pkg/client/stack"
	composetypes "github.com/docker/cli/cli/compose/types"
	"github.com/sirupsen/logrus"
)

// Type aliases to make code hints easier to understand

// AppEnv is a map of the values in an apps env config
type AppEnv = map[string]string

// AppName is AppName
type AppName = string

// AppFile represents app env files on disk without reading the contents
type AppFile struct {
	Path   string
	Server string
}

// AppFiles is a slice of appfiles
type AppFiles map[AppName]AppFile

// App reprents an app with its env file read into memory
type App struct {
	Name   AppName
	Type   string
	Domain string
	Env    AppEnv
	Server string
	Path   string
}

// StackName gets what the docker safe stack name is for the app
func (a App) StackName() string {
	return SanitiseAppName(a.Name)
}

// SORTING TYPES

// ByServer sort a slice of Apps
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 {
	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
}

// ByServerAndType sort a slice of Apps
type ByServerAndType []App

func (a ByServerAndType) Len() int      { return len(a) }
func (a ByServerAndType) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByServerAndType) Less(i, j int) bool {
	if a[i].Server == a[j].Server {
		return strings.ToLower(a[i].Type) < strings.ToLower(a[j].Type)
	}
	return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
}

// ByType sort a slice of Apps
type ByType []App

func (a ByType) Len() int      { return len(a) }
func (a ByType) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByType) Less(i, j int) bool {
	return strings.ToLower(a[i].Type) < strings.ToLower(a[j].Type)
}

// ByName sort a slice of Apps
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 {
		return App{}, fmt.Errorf("env file for '%s' couldn't be read: %s", name, err.Error())
	}

	logrus.Debugf("read env '%s' from '%s'", env, appFile.Path)

	app, err := newApp(env, name, appFile)
	if err != nil {
		return App{}, fmt.Errorf("env file for '%s' has issues: %s", name, err.Error())
	}

	return app, nil
}

// newApp creates new App object
func newApp(env AppEnv, name string, appFile AppFile) (App, error) {
	// Checking for type as it is required - apps wont work without it
	domain := env["DOMAIN"]
	apptype, ok := env["TYPE"]
	if !ok {
		return App{}, errors.New("missing TYPE variable")
	}

	return App{
		Name:   name,
		Domain: domain,
		Type:   apptype,
		Env:    env,
		Server: appFile.Server,
		Path:   appFile.Path,
	}, nil
}

// LoadAppFiles gets all app files for a given set of servers or all servers
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
			servers, err = getAllFoldersInDirectory(ABRA_SERVER_FOLDER)
			if err != nil {
				return nil, err
			}
		}
	}

	logrus.Debugf("collecting metadata from '%v' servers: '%s'", len(servers), servers)

	for _, server := range servers {
		serverDir := path.Join(ABRA_SERVER_FOLDER, server)
		files, err := getAllFilesInDirectory(serverDir)
		if err != nil {
			return nil, err
		}
		for _, file := range files {
			appName := strings.TrimSuffix(file.Name(), ".env")
			appFilePath := path.Join(ABRA_SERVER_FOLDER, server, file.Name())
			appFiles[appName] = AppFile{
				Path:   appFilePath,
				Server: server,
			}
		}
	}
	return appFiles, nil
}

// GetApp loads an apps settings, reading it from file, in preparation to use it
//
// ONLY use when ready to use the env file to keep IO down
func GetApp(apps AppFiles, name AppName) (App, error) {
	appFile, exists := apps[name]
	if !exists {
		return App{}, fmt.Errorf("cannot find app with name '%s'", name)
	}

	app, err := readAppEnvFile(appFile, name)
	if err != nil {
		return App{}, err
	}

	return app, nil
}

// GetApps returns a slice of Apps with their env files read from a given slice of AppFiles
func GetApps(appFiles AppFiles) ([]App, error) {
	var apps []App

	for name := range appFiles {
		app, err := GetApp(appFiles, name)
		if err != nil {
			return nil, err
		}
		apps = append(apps, app)
	}

	return apps, nil
}

// 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
	}

	composeFiles, err := GetAppComposeFiles(app.Type, app.Env)
	if err != nil {
		return serviceNames, err
	}

	opts := stack.Deploy{Composefiles: composeFiles}
	compose, err := GetAppComposeConfig(app.Type, opts, app.Env)
	if err != nil {
		return serviceNames, err
	}

	for _, service := range compose.Services {
		serviceNames = append(serviceNames, service.Name)
	}

	return serviceNames, nil
}

// GetAppNames retrieves a list of app names.
func GetAppNames() ([]string, error) {
	var appNames []string

	appFiles, err := LoadAppFiles("")
	if err != nil {
		return appNames, err
	}

	apps, err := GetApps(appFiles)
	if err != nil {
		return appNames, err
	}

	for _, app := range apps {
		appNames = append(appNames, app.Name)
	}

	return appNames, nil
}

// TemplateAppEnvSample copies the example env file for the app into the users env files
func TemplateAppEnvSample(appType, appName, server, domain, recipe string) error {
	envSamplePath := path.Join(ABRA_DIR, "apps", appType, ".env.sample")
	envSample, err := ioutil.ReadFile(envSamplePath)
	if err != nil {
		return err
	}

	appEnvPath := path.Join(ABRA_DIR, "servers", server, fmt.Sprintf("%s.env", appName))
	if _, err := os.Stat(appEnvPath); err == nil {
		return fmt.Errorf("%s already exists?", appEnvPath)
	}

	envSample = []byte(strings.Replace(string(envSample), fmt.Sprintf("%s.example.com", recipe), domain, -1))
	envSample = []byte(strings.Replace(string(envSample), "example.com", domain, -1))

	err = ioutil.WriteFile(appEnvPath, envSample, 0755)
	if err != nil {
		return err
	}

	logrus.Debugf("copied '%s' to '%s'", envSamplePath, appEnvPath)

	return nil
}

// SanitiseAppName makes a app name usable with Docker by replacing illegal characters
func SanitiseAppName(name string) string {
	return strings.ReplaceAll(name, ".", "_")
}

// GetAppStatuses queries servers to check the deployment status of given apps
func GetAppStatuses(appFiles AppFiles) (map[string]string, error) {
	statuses := map[string]string{}

	var unique []string
	servers := make(map[string]struct{})
	for _, appFile := range appFiles {
		if _, ok := servers[appFile.Server]; !ok {
			servers[appFile.Server] = struct{}{}
			unique = append(unique, appFile.Server)
		}
	}

	bar := formatter.CreateProgressbar(len(servers), "querying remote servers...")
	ch := make(chan stack.StackStatus, len(servers))
	for server := range servers {
		go func(s string) {
			ch <- stack.GetAllDeployedServices(s)
			bar.Add(1)
		}(server)
	}

	for range servers {
		status := <-ch
		for _, service := range status.Services {
			name := service.Spec.Labels[convert.LabelNamespace]
			if _, ok := statuses[name]; !ok {
				statuses[name] = "deployed"
			}
		}
	}

	logrus.Debugf("retrieved app statuses: '%s'", statuses)

	return statuses, nil
}

// 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) {
	if _, ok := appEnv["COMPOSE_FILE"]; !ok {
		logrus.Debug("no COMPOSE_FILE detected, loading all compose files")
		pattern := fmt.Sprintf("%s/%s/compose**yml", APPS_DIR, recipe)
		composeFiles, err := filepath.Glob(pattern)
		if err != nil {
			return composeFiles, err
		}
		return composeFiles, nil
	}

	var composeFiles []string
	composeFileEnvVar := appEnv["COMPOSE_FILE"]
	envVars := strings.Split(composeFileEnvVar, ":")
	logrus.Debugf("COMPOSE_FILE detected ('%s'), loading '%s'", composeFileEnvVar, envVars)
	for _, file := range strings.Split(composeFileEnvVar, ":") {
		path := fmt.Sprintf("%s/%s/%s", APPS_DIR, recipe, file)
		composeFiles = append(composeFiles, path)
	}

	logrus.Debugf("retrieved '%s' configs for '%s'", strings.Join(composeFiles, ", "), recipe)

	return composeFiles, nil
}

// 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) {
	compose, err := loader.LoadComposefile(opts, appEnv)
	if err != nil {
		return &composetypes.Config{}, err
	}

	logrus.Debugf("retrieved '%s' for '%s'", compose.Filename, recipe)

	return compose, nil
}