315 lines
9.4 KiB
Go
315 lines
9.4 KiB
Go
package deploy
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sort"
|
|
"strings"
|
|
|
|
appPkg "coopcloud.tech/abra/pkg/app"
|
|
"coopcloud.tech/abra/pkg/envfile"
|
|
"coopcloud.tech/abra/pkg/formatter"
|
|
"coopcloud.tech/abra/pkg/i18n"
|
|
"coopcloud.tech/abra/pkg/log"
|
|
"coopcloud.tech/abra/pkg/recipe"
|
|
"coopcloud.tech/abra/pkg/secret"
|
|
|
|
"github.com/distribution/reference"
|
|
composetypes "github.com/docker/cli/cli/compose/types"
|
|
"github.com/docker/docker/api/types/swarm"
|
|
dockerClient "github.com/docker/docker/client"
|
|
)
|
|
|
|
// MergeAbraShEnv merges abra.sh env vars into the app env vars.
|
|
func MergeAbraShEnv(recipe recipe.Recipe, env envfile.AppEnv) error {
|
|
abraShEnv, err := envfile.ReadAbraShEnvVars(recipe.AbraShPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for k, v := range abraShEnv {
|
|
log.Debugf("read v:%s k: %s", v, k)
|
|
env[k] = v
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetEntityNameAndVersion parses a full config name like `app_example_com_someconf_v1` to extract name and version, ("someconf", "v1")
|
|
func GetEntityNameAndVersion(fullName string, stackName string) (string, string, error) {
|
|
name := strings.TrimPrefix(fullName, stackName+"_")
|
|
if lastUnderscore := strings.LastIndex(name, "_"); lastUnderscore != -1 {
|
|
return name[0:lastUnderscore], name[lastUnderscore+1:], nil
|
|
}
|
|
return "", "", errors.New(i18n.G("can't parse version from '%s'", fullName))
|
|
}
|
|
|
|
func GetSecretsForStack(cl *dockerClient.Client, app appPkg.App) (map[string]string, error) {
|
|
filters, err := app.Filters(false, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// List all services in the stack
|
|
// NOTE: we could do cl.SecretList, but we want to know which secrets are actually attached
|
|
services, err := cl.ServiceList(context.Background(), swarm.ServiceListOptions{
|
|
Filters: filters,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
secrets := make(map[string]string)
|
|
|
|
for _, service := range services {
|
|
if service.Spec.TaskTemplate.ContainerSpec.Secrets != nil {
|
|
for _, secretRef := range service.Spec.TaskTemplate.ContainerSpec.Secrets {
|
|
secretName := secretRef.SecretName
|
|
if secretName == "" {
|
|
continue
|
|
}
|
|
secretBaseName, secretVersion, err := GetEntityNameAndVersion(secretName, app.StackName())
|
|
if err != nil {
|
|
log.Warn(err)
|
|
continue
|
|
}
|
|
|
|
existingSecretVersion, exists := secrets[secretBaseName]
|
|
if !exists {
|
|
// First time seeing this, add to map
|
|
secrets[secretBaseName] = secretVersion
|
|
} else {
|
|
// Just make sure the versions are the same..
|
|
if existingSecretVersion != secretVersion {
|
|
log.Warnf(i18n.G("different versions for secret '%s', '%s' and %s'", secretBaseName, existingSecretVersion, secretVersion))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return secrets, nil
|
|
}
|
|
|
|
// GetConfigsForStack retrieves all Docker configs attached to services in a given stack.
|
|
func GetConfigsForStack(cl *dockerClient.Client, app appPkg.App) (map[string]string, error) {
|
|
filters, err := app.Filters(false, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// List all services in the stack
|
|
services, err := cl.ServiceList(context.Background(), swarm.ServiceListOptions{
|
|
Filters: filters,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Collect unique config names with versions
|
|
configs := make(map[string]string)
|
|
for _, service := range services {
|
|
if service.Spec.TaskTemplate.ContainerSpec != nil {
|
|
for _, configRef := range service.Spec.TaskTemplate.ContainerSpec.Configs {
|
|
configName := configRef.ConfigName
|
|
if configName == "" {
|
|
continue
|
|
}
|
|
configBaseName, configVersion, err := GetEntityNameAndVersion(configName, app.StackName())
|
|
if err != nil {
|
|
log.Warn(err)
|
|
continue
|
|
}
|
|
|
|
existingConfigVersion, ok := configs[configBaseName]
|
|
if !ok {
|
|
// First time seeing this, add to map
|
|
configs[configBaseName] = configVersion
|
|
} else {
|
|
// Just make sure the versions are the same..
|
|
if existingConfigVersion != configVersion {
|
|
log.Warnf(i18n.G("different versions for config '%s', '%s' and %s'", configBaseName, existingConfigVersion, configVersion))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return configs, nil
|
|
}
|
|
|
|
// GetImagesForStack retrieves all Docker images for services in a given stack.
|
|
func GetImagesForStack(cl *dockerClient.Client, app appPkg.App) (map[string]string, error) {
|
|
filters, err := app.Filters(false, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// List all services in the stack
|
|
services, err := cl.ServiceList(context.Background(), swarm.ServiceListOptions{
|
|
Filters: filters,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Collect unique image names with versions
|
|
images := make(map[string]string)
|
|
for _, service := range services {
|
|
if service.Spec.TaskTemplate.ContainerSpec != nil {
|
|
imageName := service.Spec.TaskTemplate.ContainerSpec.Image
|
|
|
|
imageParsed, err := reference.ParseNormalizedNamed(imageName)
|
|
if err != nil {
|
|
log.Warn(err)
|
|
continue
|
|
}
|
|
|
|
imageBaseName := reference.Path(imageParsed)
|
|
imageTag := imageParsed.(reference.NamedTagged).Tag()
|
|
|
|
existingImageVersion, ok := images[imageBaseName]
|
|
if !ok {
|
|
// First time seeing this, add to map
|
|
images[imageBaseName] = imageTag
|
|
} else {
|
|
// Just make sure the versions are the same..
|
|
if existingImageVersion != imageTag {
|
|
log.Warnf(i18n.G("different versions for image '%s', '%s' and %s'", imageBaseName, existingImageVersion, imageTag))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return images, nil
|
|
}
|
|
|
|
func GatherSecretsForDeploy(cl *dockerClient.Client, app appPkg.App, showUnchanged bool) ([]string, error) {
|
|
// Get current secrets from existing deployment
|
|
currentSecrets, err := GetSecretsForStack(cl, app)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
log.Debugf("current secrets: %v", currentSecrets)
|
|
|
|
newSecrets, err := secret.PollSecretsStatus(cl, app)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Sort secrets to ensure reproducible output
|
|
sort.Slice(newSecrets, func(i, j int) bool {
|
|
return newSecrets[i].LocalName < newSecrets[j].LocalName
|
|
})
|
|
|
|
var secretInfo []string
|
|
|
|
for _, newSecret := range newSecrets {
|
|
if currentVersion, exists := currentSecrets[newSecret.LocalName]; exists {
|
|
if currentVersion == newSecret.Version {
|
|
if showUnchanged {
|
|
secretInfo = append(secretInfo, i18n.G("%s: %s (unchanged)", newSecret.LocalName, newSecret.Version))
|
|
}
|
|
} else {
|
|
secretInfo = append(secretInfo, i18n.G("%s: %s → %s", newSecret.LocalName, currentVersion, newSecret.Version))
|
|
}
|
|
} else {
|
|
secretInfo = append(secretInfo, i18n.G("%s: %s (new)", newSecret.LocalName, newSecret.Version))
|
|
}
|
|
}
|
|
|
|
return secretInfo, nil
|
|
}
|
|
|
|
func GatherConfigsForDeploy(cl *dockerClient.Client, app appPkg.App, compose *composetypes.Config, abraShEnv map[string]string, showUnchanged bool) ([]string, error) {
|
|
// Get current configs from existing deployment
|
|
currentConfigs, err := GetConfigsForStack(cl, app)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
log.Debugf(i18n.G("deployed config names: %v", currentConfigs))
|
|
|
|
// Get new configs from the compose specification
|
|
newConfigs := compose.Configs
|
|
|
|
var configInfo []string
|
|
for configName := range newConfigs {
|
|
log.Debugf(i18n.G("searching abra.sh for version for %s", configName))
|
|
versionKey := strings.ToUpper(configName) + "_VERSION"
|
|
newVersion, exists := abraShEnv[versionKey]
|
|
if !exists {
|
|
log.Warnf(i18n.G("no version found for config %s", configName))
|
|
configInfo = append(configInfo, i18n.G("%s: ? (missing version)", configName))
|
|
continue
|
|
}
|
|
|
|
if currentVersion, exists := currentConfigs[configName]; exists {
|
|
if currentVersion == newVersion {
|
|
if showUnchanged {
|
|
configInfo = append(configInfo, i18n.G("%s: %s (unchanged)", configName, newVersion))
|
|
}
|
|
} else {
|
|
configInfo = append(configInfo, i18n.G("%s: %s → %s", configName, currentVersion, newVersion))
|
|
}
|
|
} else {
|
|
configInfo = append(configInfo, i18n.G("%s: %s (new)", configName, newVersion))
|
|
}
|
|
}
|
|
|
|
return configInfo, nil
|
|
}
|
|
|
|
func GatherImagesForDeploy(cl *dockerClient.Client, app appPkg.App, compose *composetypes.Config, showUnchanged bool) ([]string, error) {
|
|
// Get current images from existing deployment
|
|
currentImages, err := GetImagesForStack(cl, app)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
log.Debugf(i18n.G("deployed images: %v", currentImages))
|
|
|
|
// Proposed new images from the compose files
|
|
newImages := make(map[string]string)
|
|
|
|
for _, service := range compose.Services {
|
|
imageParsed, err := reference.ParseNormalizedNamed(service.Image)
|
|
if err != nil {
|
|
log.Warn(err)
|
|
continue
|
|
}
|
|
|
|
imageBaseName := reference.Path(imageParsed)
|
|
imageTag := imageParsed.(reference.NamedTagged).Tag()
|
|
|
|
existingImageVersion, ok := newImages[imageBaseName]
|
|
if !ok {
|
|
// First time seeing this, add to map
|
|
newImages[imageBaseName] = imageTag
|
|
} else {
|
|
// Just make sure the versions are the same..
|
|
if existingImageVersion != imageTag {
|
|
log.Warnf(i18n.G("different versions for image '%s', '%s' and %s'", imageBaseName, existingImageVersion, imageTag))
|
|
}
|
|
}
|
|
}
|
|
log.Debugf(i18n.G("proposed images: %v", newImages))
|
|
|
|
var imageInfo []string
|
|
for newImageName, newImageVersion := range newImages {
|
|
if currentVersion, exists := currentImages[newImageName]; exists {
|
|
if currentVersion == newImageVersion {
|
|
if showUnchanged {
|
|
imageInfo = append(imageInfo, i18n.G("%s: %s (unchanged)", formatter.StripTagMeta(newImageName), newImageVersion))
|
|
}
|
|
} else {
|
|
imageInfo = append(imageInfo, i18n.G("%s: %s → %s", formatter.StripTagMeta(newImageName), currentVersion, newImageVersion))
|
|
}
|
|
} else {
|
|
imageInfo = append(imageInfo, i18n.G("%s: %s (new)", formatter.StripTagMeta(newImageName), newImageVersion))
|
|
}
|
|
}
|
|
|
|
return imageInfo, nil
|
|
}
|