toolshed/abra
toolshed/abra
4
2
Fork 18
Code Issues 29 Pull Requests 3 Packages Releases 40 Activity

refactor(recipe): remove remaining usage of old recipe struct

Browse Source
This commit is contained in:
p4u1 2024-07-08 13:15:20 +02:00
parent c1b03bcbd7
commit 5617a9ba07
24 changed files with 167 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
cli/app/backup.go
View File

@ -7,7 +7,6 @@ import (
"coopcloud.tech/abra/pkg/autocomplete"
"coopcloud.tech/abra/pkg/client"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
"github.com/urfave/cli"
)
@ -47,8 +46,7 @@ var appBackupListCommand = cli.Command{
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
@ -94,24 +92,23 @@ var appBackupDownloadCommand = cli.Command{
BashComplete: autocomplete.AppNameComplete,
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.EnsureExists(); err != nil {
if err := app.Recipe.EnsureExists(); err != nil {
log.Fatal(err)
}
if !internal.Chaos {
if err := r.EnsureIsClean(); err != nil {
if err := app.Recipe.EnsureIsClean(); err != nil {
log.Fatal(err)
}
if !internal.Offline {
if err := r.EnsureUpToDate(); err != nil {
if err := app.Recipe.EnsureUpToDate(); err != nil {
log.Fatal(err)
}
}
if err := r.EnsureLatest(); err != nil {
if err := app.Recipe.EnsureLatest(); err != nil {
log.Fatal(err)
}
}
@ -165,24 +162,23 @@ var appBackupCreateCommand = cli.Command{
BashComplete: autocomplete.AppNameComplete,
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.EnsureExists(); err != nil {
if err := app.Recipe.EnsureExists(); err != nil {
log.Fatal(err)
}
if !internal.Chaos {
if err := r.EnsureIsClean(); err != nil {
if err := app.Recipe.EnsureIsClean(); err != nil {
log.Fatal(err)
}
if !internal.Offline {
if err := r.EnsureUpToDate(); err != nil {
if err := app.Recipe.EnsureUpToDate(); err != nil {
log.Fatal(err)
}
}
if err := r.EnsureLatest(); err != nil {
if err := app.Recipe.EnsureLatest(); err != nil {
log.Fatal(err)
}
}
@ -224,24 +220,23 @@ var appBackupSnapshotsCommand = cli.Command{
BashComplete: autocomplete.AppNameComplete,
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.EnsureExists(); err != nil {
if err := app.Recipe.EnsureExists(); err != nil {
log.Fatal(err)
}
if !internal.Chaos {
if err := r.EnsureIsClean(); err != nil {
if err := app.Recipe.EnsureIsClean(); err != nil {
log.Fatal(err)
}
if !internal.Offline {
if err := r.EnsureUpToDate(); err != nil {
if err := app.Recipe.EnsureUpToDate(); err != nil {
log.Fatal(err)
}
}
if err := r.EnsureLatest(); err != nil {
if err := app.Recipe.EnsureLatest(); err != nil {
log.Fatal(err)
}
}

4
cli/app/check.go
View File

@ -6,7 +6,6 @@ import (
"coopcloud.tech/abra/pkg/autocomplete"
"coopcloud.tech/abra/pkg/formatter"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
"github.com/urfave/cli"
)
@ -37,8 +36,7 @@ ${FOO:<default>} syntax). "check" does not confirm or deny this for you.`,
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}

9
cli/app/cmd.go
View File

@ -60,8 +60,7 @@ Example:
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
@ -71,7 +70,7 @@ Example:
hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args(), internal.LocalCmd)
abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
abraSh := path.Join(config.RECIPES_DIR, app.Recipe.Name, "abra.sh")
if _, err := os.Stat(abraSh); err != nil {
if os.IsNotExist(err) {
log.Fatalf("%s does not exist for %s?", abraSh, app.Name)
@ -85,7 +84,7 @@ Example:
}
cmdName := c.Args().Get(1)
if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
if err := internal.EnsureCommand(abraSh, app.Recipe.Name, cmdName); err != nil {
log.Fatal(err)
}
@ -123,7 +122,7 @@ Example:
targetServiceName := c.Args().Get(1)
cmdName := c.Args().Get(2)
if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
if err := internal.EnsureCommand(abraSh, app.Recipe.Name, cmdName); err != nil {
log.Fatal(err)
}

21
cli/app/deploy.go
View File

@ -58,12 +58,11 @@ recipes.
log.Fatal("cannot use <version> and --chaos together")
}
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
if err := lint.LintForErrors(r); err != nil {
if err := lint.LintForErrors(app.Recipe); err != nil {
log.Fatal(err)
}
@ -87,7 +86,7 @@ recipes.
if specificVersion != "" {
version = specificVersion
log.Debugf("choosing %s as version to deploy", version)
if err := r.EnsureVersion(version); err != nil {
if err := app.Recipe.EnsureVersion(version); err != nil {
log.Fatal(err)
}
}
@ -116,14 +115,14 @@ recipes.
if err != nil {
log.Fatal(err)
}
versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe.Name, catl)
if err != nil {
log.Fatal(err)
}
if len(versions) == 0 && !internal.Chaos {
log.Warn("no published versions in catalogue, trying local recipe repository")
recipeVersions, err := r.GetRecipeVersions(internal.Offline)
recipeVersions, err := app.Recipe.GetRecipeVersions(internal.Offline)
if err != nil {
log.Warn(err)
}
@ -137,11 +136,11 @@ recipes.
if len(versions) > 0 && !internal.Chaos {
version = versions[len(versions)-1]
log.Debugf("choosing %s as version to deploy", version)
if err := r.EnsureVersion(version); err != nil {
if err := app.Recipe.EnsureVersion(version); err != nil {
log.Fatal(err)
}
} else {
head, err := git.GetRecipeHead(app.Recipe)
head, err := git.GetRecipeHead(app.Recipe.Name)
if err != nil {
log.Fatal(err)
}
@ -153,7 +152,7 @@ recipes.
if internal.Chaos {
log.Warnf("chaos mode engaged")
var err error
version, err = r.ChaosVersion()
version, err = app.Recipe.ChaosVersion()
if err != nil {
log.Fatal(err)
}
@ -168,7 +167,7 @@ recipes.
app.Env[k] = v
}
composeFiles, err := r.GetComposeFiles(app.Env)
composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
if err != nil {
log.Fatal(err)
}
@ -186,7 +185,7 @@ recipes.
}
appPkg.ExposeAllEnv(stackName, compose, app.Env)
appPkg.SetRecipeLabel(compose, stackName, app.Recipe)
appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
appPkg.SetChaosVersionLabel(compose, stackName, version)
appPkg.SetUpdateLabel(compose, stackName, app.Env)

30
cli/app/list.go
View File

@ -16,28 +16,34 @@ import (
"github.com/urfave/cli"
)
var status bool
var statusFlag = &cli.BoolFlag{
var (
status bool
statusFlag = &cli.BoolFlag{
Name: "status, S",
Usage: "Show app deployment status",
Destination: &status,
}
}
)
var recipeFilter string
var recipeFlag = &cli.StringFlag{
var (
recipeFilter string
recipeFlag = &cli.StringFlag{
Name: "recipe, r",
Value: "",
Usage: "Show apps of a specific recipe",
Destination: &recipeFilter,
}
}
)
var listAppServer string
var listAppServerFlag = &cli.StringFlag{
var (
listAppServer string
listAppServerFlag = &cli.StringFlag{
Name: "server, s",
Value: "",
Usage: "Show apps of a specific server",
Destination: &listAppServer,
}
}
)
type appStatus struct {
Server string `json:"server"`
@ -130,7 +136,7 @@ can take some time.
}
}
if app.Recipe == recipeFilter || recipeFilter == "" {
if app.Recipe.Name == recipeFilter || recipeFilter == "" {
if recipeFilter != "" {
// only count server if matches filter
totalServersCount++
@ -177,7 +183,7 @@ can take some time.
var newUpdates []string
if version != "unknown" {
updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe.Name, catl)
if err != nil {
log.Fatal(err)
}
@ -214,7 +220,7 @@ can take some time.
}
appStats.Server = app.Server
appStats.Recipe = app.Recipe
appStats.Recipe = app.Recipe.Name
appStats.AppName = app.Name
appStats.Domain = app.Domain

4
cli/app/logs.go
View File

@ -13,7 +13,6 @@ import (
"coopcloud.tech/abra/pkg/autocomplete"
"coopcloud.tech/abra/pkg/client"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
"coopcloud.tech/abra/pkg/upstream/stack"
"github.com/docker/docker/api/types"
containerTypes "github.com/docker/docker/api/types/container"
@ -38,9 +37,8 @@ var appLogsCommand = cli.Command{
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
stackName := app.StackName()
r := recipe.Get2(app.Recipe)
if err := r.EnsureExists(); err != nil {
if err := app.Recipe.EnsureExists(); err != nil {
log.Fatal(err)
}

23
cli/app/new.go
View File

@ -66,21 +66,20 @@ var appNewCommand = cli.Command{
},
Action: func(c *cli.Context) error {
recipe := internal.ValidateRecipe(c)
r := recipePkg.Get2(recipe.Name)
if !internal.Chaos {
if err := r.EnsureIsClean(); err != nil {
if err := recipe.EnsureIsClean(); err != nil {
log.Fatal(err)
}
if !internal.Offline {
if err := r.EnsureUpToDate(); err != nil {
if err := recipe.EnsureUpToDate(); err != nil {
log.Fatal(err)
}
}
if c.Args().Get(1) == "" {
var version string
recipeVersions, err := r.GetRecipeVersions(internal.Offline)
recipeVersions, err := recipe.GetRecipeVersions(internal.Offline)
if err != nil {
log.Fatal(err)
}
@ -93,16 +92,16 @@ var appNewCommand = cli.Command{
version = tag
}
if err := r.EnsureVersion(version); err != nil {
if err := recipe.EnsureVersion(version); err != nil {
log.Fatal(err)
}
} else {
if err := r.EnsureLatest(); err != nil {
if err := recipe.EnsureLatest(); err != nil {
log.Fatal(err)
}
}
} else {
if err := r.EnsureVersion(c.Args().Get(1)); err != nil {
if err := recipe.EnsureVersion(c.Args().Get(1)); err != nil {
log.Fatal(err)
}
}
@ -120,7 +119,7 @@ var appNewCommand = cli.Command{
log.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName)
if err := appPkg.TemplateAppEnvSample(
r,
recipe,
internal.Domain,
internal.NewAppServer,
internal.Domain,
@ -131,17 +130,17 @@ var appNewCommand = cli.Command{
var secrets AppSecrets
var secretTable *jsontable.JSONTable
if internal.Secrets {
sampleEnv, err := r.SampleEnv()
sampleEnv, err := recipe.SampleEnv()
if err != nil {
log.Fatal(err)
}
composeFiles, err := r.GetComposeFiles(sampleEnv)
composeFiles, err := recipe.GetComposeFiles(sampleEnv)
if err != nil {
log.Fatal(err)
}
secretsConfig, err := secret.ReadSecretsConfig(r.SampleEnvPath, composeFiles, appPkg.StackName(internal.Domain))
secretsConfig, err := secret.ReadSecretsConfig(recipe.SampleEnvPath, composeFiles, appPkg.StackName(internal.Domain))
if err != nil {
return err
}
@ -231,7 +230,7 @@ func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secr
}
// ensureDomainFlag checks if the domain flag was used. if not, asks the user for it/
func ensureDomainFlag(recipe recipePkg.Recipe, server string) error {
func ensureDomainFlag(recipe recipePkg.Recipe2, server string) error {
if internal.Domain == "" && !internal.NoInput {
prompt := &survey.Input{
Message: "Specify app domain",

3
cli/app/ps.go
View File

@ -35,7 +35,6 @@ var appPsCommand = cli.Command{
BashComplete: autocomplete.AppNameComplete,
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
cl, err := client.New(app.Server)
if err != nil {
@ -54,7 +53,7 @@ var appPsCommand = cli.Command{
statuses, err := appPkg.GetAppStatuses([]appPkg.App{app}, true)
if statusMeta, ok := statuses[app.StackName()]; ok {
if _, exists := statusMeta["chaos"]; !exists {
if err := r.EnsureVersion(deployedVersion); err != nil {
if err := app.Recipe.EnsureVersion(deployedVersion); err != nil {
log.Fatal(err)
}
}

4
cli/app/restore.go
View File

@ -7,7 +7,6 @@ import (
"coopcloud.tech/abra/pkg/autocomplete"
"coopcloud.tech/abra/pkg/client"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
"github.com/urfave/cli"
)
@ -33,8 +32,7 @@ var appRestoreCommand = cli.Command{
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}

17
cli/app/rollback.go
View File

@ -58,12 +58,11 @@ recipes.
log.Fatal("cannot use <version> and --chaos together")
}
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
if err := lint.LintForErrors(r); err != nil {
if err := lint.LintForErrors(app.Recipe); err != nil {
log.Fatal(err)
}
@ -88,14 +87,14 @@ recipes.
log.Fatal(err)
}
versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe.Name, catl)
if err != nil {
log.Fatal(err)
}
if len(versions) == 0 && !internal.Chaos {
log.Warn("no published versions in catalogue, trying local recipe repository")
recipeVersions, err := r.GetRecipeVersions(internal.Offline)
recipeVersions, err := app.Recipe.GetRecipeVersions(internal.Offline)
if err != nil {
log.Warn(err)
}
@ -165,7 +164,7 @@ recipes.
}
if !internal.Chaos {
if err := r.EnsureVersion(chosenDowngrade); err != nil {
if err := app.Recipe.EnsureVersion(chosenDowngrade); err != nil {
log.Fatal(err)
}
}
@ -173,7 +172,7 @@ recipes.
if internal.Chaos {
log.Warn("chaos mode engaged")
var err error
chosenDowngrade, err = r.ChaosVersion()
chosenDowngrade, err = app.Recipe.ChaosVersion()
if err != nil {
log.Fatal(err)
}
@ -188,7 +187,7 @@ recipes.
app.Env[k] = v
}
composeFiles, err := r.GetComposeFiles(app.Env)
composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
if err != nil {
log.Fatal(err)
}
@ -204,7 +203,7 @@ recipes.
log.Fatal(err)
}
appPkg.ExposeAllEnv(stackName, compose, app.Env)
appPkg.SetRecipeLabel(compose, stackName, app.Recipe)
appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
appPkg.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
appPkg.SetUpdateLabel(compose, stackName, app.Env)

26
cli/app/secret.go
View File

@ -14,7 +14,6 @@ import (
"coopcloud.tech/abra/pkg/client"
"coopcloud.tech/abra/pkg/formatter"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
"coopcloud.tech/abra/pkg/secret"
"github.com/docker/docker/api/types"
dockerClient "github.com/docker/docker/client"
@ -57,8 +56,7 @@ var appSecretGenerateCommand = cli.Command{
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
@ -72,7 +70,7 @@ var appSecretGenerateCommand = cli.Command{
internal.ShowSubcommandHelpAndError(c, err)
}
composeFiles, err := r.GetComposeFiles(app.Env)
composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
if err != nil {
log.Fatal(err)
}
@ -248,29 +246,28 @@ Example:
`,
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.EnsureExists(); err != nil {
if err := app.Recipe.EnsureExists(); err != nil {
log.Fatal(err)
}
if !internal.Chaos {
if err := r.EnsureIsClean(); err != nil {
if err := app.Recipe.EnsureIsClean(); err != nil {
log.Fatal(err)
}
if !internal.Offline {
if err := r.EnsureUpToDate(); err != nil {
if err := app.Recipe.EnsureUpToDate(); err != nil {
log.Fatal(err)
}
}
if err := r.EnsureLatest(); err != nil {
if err := app.Recipe.EnsureLatest(); err != nil {
log.Fatal(err)
}
}
composeFiles, err := r.GetComposeFiles(app.Env)
composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
if err != nil {
log.Fatal(err)
}
@ -357,24 +354,23 @@ var appSecretLsCommand = cli.Command{
BashComplete: autocomplete.AppNameComplete,
Action: func(c *cli.Context) error {
app := internal.ValidateApp(c)
r := recipe.Get2(app.Recipe)
if err := r.EnsureExists(); err != nil {
if err := app.Recipe.EnsureExists(); err != nil {
log.Fatal(err)
}
if !internal.Chaos {
if err := r.EnsureIsClean(); err != nil {
if err := app.Recipe.EnsureIsClean(); err != nil {
log.Fatal(err)
}
if !internal.Offline {
if err := r.EnsureUpToDate(); err != nil {
if err := app.Recipe.EnsureUpToDate(); err != nil {
log.Fatal(err)
}
}
if err := r.EnsureLatest(); err != nil {
if err := app.Recipe.EnsureLatest(); err != nil {
log.Fatal(err)
}
}

21
cli/app/upgrade.go
View File

@ -12,7 +12,6 @@ import (
"coopcloud.tech/abra/pkg/envfile"
"coopcloud.tech/abra/pkg/lint"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
recipePkg "coopcloud.tech/abra/pkg/recipe"
stack "coopcloud.tech/abra/pkg/upstream/stack"
"coopcloud.tech/tagcmp"
@ -64,13 +63,11 @@ recipes.
log.Fatal("cannot use <version> and --chaos together")
}
r := recipe.Get2(app.Recipe)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := app.Recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
r2 := recipePkg.Get2(app.Recipe)
if err := lint.LintForErrors(r2); err != nil {
if err := lint.LintForErrors(app.Recipe); err != nil {
log.Fatal(err)
}
@ -95,14 +92,14 @@ recipes.
log.Fatal(err)
}
versions, err := recipePkg.GetRecipeCatalogueVersions(app.Recipe, catl)
versions, err := recipePkg.GetRecipeCatalogueVersions(app.Recipe.Name, catl)
if err != nil {
log.Fatal(err)
}
if len(versions) == 0 && !internal.Chaos {
log.Warn("no published versions in catalogue, trying local recipe repository")
recipeVersions, err := r2.GetRecipeVersions(internal.Offline)
recipeVersions, err := app.Recipe.GetRecipeVersions(internal.Offline)
if err != nil {
log.Warn(err)
}
@ -192,7 +189,7 @@ recipes.
log.Fatal(err)
}
if parsedVersion.IsGreaterThan(parsedDeployedVersion) && parsedVersion.IsLessThan(parsedChosenUpgrade) {
note, err := internal.GetReleaseNotes(app.Recipe, version)
note, err := internal.GetReleaseNotes(app.Recipe.Name, version)
if err != nil {
return err
}
@ -204,7 +201,7 @@ recipes.
}
if !internal.Chaos {
if err := r.EnsureVersion(chosenUpgrade); err != nil {
if err := app.Recipe.EnsureVersion(chosenUpgrade); err != nil {
log.Fatal(err)
}
}
@ -212,7 +209,7 @@ recipes.
if internal.Chaos {
log.Warn("chaos mode engaged")
var err error
chosenUpgrade, err = r.ChaosVersion()
chosenUpgrade, err = app.Recipe.ChaosVersion()
if err != nil {
log.Fatal(err)
}
@ -227,7 +224,7 @@ recipes.
app.Env[k] = v
}
composeFiles, err := r.GetComposeFiles(app.Env)
composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
if err != nil {
log.Fatal(err)
}
@ -243,7 +240,7 @@ recipes.
log.Fatal(err)
}
appPkg.ExposeAllEnv(stackName, compose, app.Env)
appPkg.SetRecipeLabel(compose, stackName, app.Recipe)
appPkg.SetRecipeLabel(compose, stackName, app.Recipe.Name)
appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
appPkg.SetChaosVersionLabel(compose, stackName, chosenUpgrade)
appPkg.SetUpdateLabel(compose, stackName, app.Env)

2
cli/app/version.go
View File

@ -78,7 +78,7 @@ var appVersionCommand = cli.Command{
log.Fatalf("failed to determine version of deployed %s", app.Name)
}
recipeMeta, err := recipe.GetRecipeMeta(app.Recipe, internal.Offline)
recipeMeta, err := recipe.GetRecipeMeta(app.Recipe.Name, internal.Offline)
if err != nil {
log.Fatal(err)
}

8
cli/internal/deploy.go
View File

@ -30,7 +30,7 @@ func NewVersionOverview(app appPkg.App, currentVersion, newVersion, releaseNotes
server = "local"
}
table.Append([]string{server, app.Recipe, deployConfig, app.Domain, currentVersion, newVersion})
table.Append([]string{server, app.Recipe.Name, deployConfig, app.Domain, currentVersion, newVersion})
table.Render()
if releaseNotes != "" && newVersion != "" {
@ -84,7 +84,7 @@ func GetReleaseNotes(recipeName, version string) (string, error) {
// the commands string must have the following format:
// "<service> <command> <arguments>|<service> <command> <arguments>|... "
func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error {
abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
abraSh := path.Join(config.RECIPES_DIR, app.Recipe.Name, "abra.sh")
if _, err := os.Stat(abraSh); err != nil {
if os.IsNotExist(err) {
return fmt.Errorf(fmt.Sprintf("%s does not exist for %s?", abraSh, app.Name))
@ -105,7 +105,7 @@ func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error {
}
log.Infof("running post-command '%s %s' in container %s", cmdName, parsedCmdArgs, targetServiceName)
if err := EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
if err := EnsureCommand(abraSh, app.Recipe.Name, cmdName); err != nil {
return err
}
@ -150,7 +150,7 @@ func DeployOverview(app appPkg.App, version, message string) error {
server = "local"
}
table.Append([]string{server, app.Recipe, deployConfig, app.Domain, version})
table.Append([]string{server, app.Recipe.Name, deployConfig, app.Domain, version})
table.Render()
if NoInput {

9
cli/internal/validate.go
View File

@ -13,7 +13,7 @@ import (
)
// ValidateRecipe ensures the recipe arg is valid.
func ValidateRecipe(c *cli.Context) recipe.Recipe {
func ValidateRecipe(c *cli.Context) recipe.Recipe2 {
recipeName := c.Args().First()
if recipeName == "" && !NoInput {
@ -57,7 +57,12 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe {
ShowSubcommandHelpAndError(c, errors.New("no recipe name provided"))
}
chosenRecipe, err := recipe.Get(recipeName, Offline)
chosenRecipe := recipe.Get2(recipeName)
err := chosenRecipe.EnsureExists()
if err != nil {
log.Fatal(err)
}
_, err = chosenRecipe.GetComposeConfig(nil)
if err != nil {
if c.Command.Name == "generate" {
if strings.Contains(err.Error(), "missing a compose") {

8
cli/recipe/lint.go
View File

@ -8,7 +8,6 @@ import (
"coopcloud.tech/abra/pkg/formatter"
"coopcloud.tech/abra/pkg/lint"
"coopcloud.tech/abra/pkg/log"
recipePkg "coopcloud.tech/abra/pkg/recipe"
"github.com/urfave/cli"
)
@ -29,8 +28,7 @@ var recipeLintCommand = cli.Command{
Action: func(c *cli.Context) error {
recipe := internal.ValidateRecipe(c)
r := recipePkg.Get2(recipe.Name)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
@ -47,7 +45,7 @@ var recipeLintCommand = cli.Command{
}
skipped := false
if rule.Skip(r) {
if rule.Skip(recipe) {
skipped = true
}
@ -58,7 +56,7 @@ var recipeLintCommand = cli.Command{
satisfied := false
if !skipped {
ok, err := rule.Function(r)
ok, err := rule.Function(recipe)
if err != nil {
log.Warn(err)
}

20
cli/recipe/release.go
View File

@ -15,7 +15,6 @@ import (
gitPkg "coopcloud.tech/abra/pkg/git"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
recipePkg "coopcloud.tech/abra/pkg/recipe"
"coopcloud.tech/tagcmp"
"github.com/AlecAivazis/survey/v2"
"github.com/distribution/reference"
@ -63,14 +62,13 @@ your SSH keys configured on your account.
BashComplete: autocomplete.RecipeNameComplete,
Action: func(c *cli.Context) error {
recipe := internal.ValidateRecipe(c)
r := recipePkg.Get2(recipe.Name)
imagesTmp, err := getImageVersions(r)
imagesTmp, err := getImageVersions(recipe)
if err != nil {
log.Fatal(err)
}
mainApp, err := internal.GetMainAppImage(r)
mainApp, err := internal.GetMainAppImage(recipe)
if err != nil {
log.Fatal(err)
}
@ -92,45 +90,45 @@ your SSH keys configured on your account.
}
if tagString != "" {
if err := createReleaseFromTag(r, tagString, mainAppVersion); err != nil {
if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
log.Fatal(err)
}
}
tags, err := r.Tags()
tags, err := recipe.Tags()
if err != nil {
log.Fatal(err)
}
if tagString == "" && (!internal.Major && !internal.Minor && !internal.Patch) {
var err error
tagString, err = getLabelVersion(r, false)
tagString, err = getLabelVersion(recipe, false)
if err != nil {
log.Fatal(err)
}
}
isClean, err := gitPkg.IsClean(r.Dir)
isClean, err := gitPkg.IsClean(recipe.Dir)
if err != nil {
log.Fatal(err)
}
if !isClean {
log.Infof("%s currently has these unstaged changes 👇", recipe.Name)
if err := gitPkg.DiffUnstaged(r.Dir); err != nil {
if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
log.Fatal(err)
}
}
if len(tags) > 0 {
logrus.Warnf("previous git tags detected, assuming this is a new semver release")
if err := createReleaseFromPreviousTag(tagString, mainAppVersion, r, tags); err != nil {
if err := createReleaseFromPreviousTag(tagString, mainAppVersion, recipe, tags); err != nil {
log.Fatal(err)
}
} else {
log.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name)
if err := createReleaseFromTag(r, tagString, mainAppVersion); err != nil {
if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil {
if cleanUpErr := cleanUpTag(tagString, recipe.Name); err != nil {
log.Fatal(cleanUpErr)
}

14
cli/recipe/sync.go
View File

@ -10,7 +10,6 @@ import (
"coopcloud.tech/abra/pkg/config"
gitPkg "coopcloud.tech/abra/pkg/git"
"coopcloud.tech/abra/pkg/log"
recipePkg "coopcloud.tech/abra/pkg/recipe"
"coopcloud.tech/tagcmp"
"github.com/AlecAivazis/survey/v2"
"github.com/go-git/go-git/v5"
@ -45,21 +44,20 @@ local file system.
BashComplete: autocomplete.RecipeNameComplete,
Action: func(c *cli.Context) error {
recipe := internal.ValidateRecipe(c)
r := recipePkg.Get2(recipe.Name)
mainApp, err := internal.GetMainAppImage(r)
mainApp, err := internal.GetMainAppImage(recipe)
if err != nil {
log.Fatal(err)
}
imagesTmp, err := getImageVersions(r)
imagesTmp, err := getImageVersions(recipe)
if err != nil {
log.Fatal(err)
}
mainAppVersion := imagesTmp[mainApp]
tags, err := r.Tags()
tags, err := recipe.Tags()
if err != nil {
log.Fatal(err)
}
@ -194,20 +192,20 @@ likely to change.
mainService := "app"
label := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", nextTag)
if !internal.Dry {
if err := r.UpdateLabel("compose.y*ml", mainService, label); err != nil {
if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil {
log.Fatal(err)
}
} else {
log.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name)
}
isClean, err := gitPkg.IsClean(r.Dir)
isClean, err := gitPkg.IsClean(recipe.Dir)
if err != nil {
log.Fatal(err)
}
if !isClean {
log.Infof("%s currently has these unstaged changes 👇", recipe.Name)
if err := gitPkg.DiffUnstaged(r.Dir); err != nil {
if err := gitPkg.DiffUnstaged(recipe.Dir); err != nil {
log.Fatal(err)
}
}

9
cli/recipe/upgrade.go
View File

@ -73,8 +73,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
Action: func(c *cli.Context) error {
recipe := internal.ValidateRecipe(c)
r := recipePkg.Get2(recipe.Name)
if err := r.Ensure(internal.Chaos, internal.Offline); err != nil {
if err := recipe.Ensure(internal.Chaos, internal.Offline); err != nil {
log.Fatal(err)
}
@ -97,7 +96,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
versionsPresent := false
recipeDir := path.Join(config.RECIPES_DIR, recipe.Name)
versionsPath := path.Join(recipeDir, "versions")
var servicePins = make(map[string]imgPin)
servicePins := make(map[string]imgPin)
if _, err := os.Stat(versionsPath); err == nil {
log.Debugf("found versions file for %s", recipe.Name)
file, err := os.Open(versionsPath)
@ -130,7 +129,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
log.Debugf("did not find versions file for %s", recipe.Name)
}
config, err := r.GetComposeConfig(nil)
config, err := recipe.GetComposeConfig(nil)
if err != nil {
log.Fatal(err)
}
@ -299,7 +298,7 @@ You may invoke this command in "wizard" mode and be prompted for input:
}
}
if upgradeTag != "skip" {
ok, err := r.UpdateTag(image, upgradeTag)
ok, err := recipe.UpdateTag(image, upgradeTag)
if err != nil {
log.Fatal(err)
}

2
cli/updater/updater.go
View File

@ -438,7 +438,7 @@ func upgrade(cl *dockerclient.Client, stackName, recipeName,
app := appPkg.App{
Name: stackName,
Recipe: recipeName,
Recipe: recipe.Get2(recipeName),
Server: SERVER,
Env: env,
}

27
pkg/app/app.go
View File

@ -70,7 +70,7 @@ func GetApps(appFiles AppFiles, recipeFilter string) ([]App, error) {
}
if recipeFilter != "" {
if app.Recipe == recipeFilter {
if app.Recipe.Name == recipeFilter {
apps = append(apps, app)
}
} else {
@ -84,7 +84,7 @@ func GetApps(appFiles AppFiles, recipeFilter string) ([]App, error) {
// App reprents an app with its env file read into memory
type App struct {
Name AppName
Recipe string
Recipe recipe.Recipe2
Domain string
Env envfile.AppEnv
Server string
@ -161,14 +161,13 @@ func (a App) Filters(appendServiceNames, exactMatch bool, services ...string) (f
return filters, nil
}
r := recipe.Get2(a.Recipe)
composeFiles, err := r.GetComposeFiles(a.Env)
composeFiles, err := a.Recipe.GetComposeFiles(a.Env)
if err != nil {
return filters, err
}
opts := stack.Deploy{Composefiles: composeFiles}
compose, err := GetAppComposeConfig(a.Recipe, opts, a.Env)
compose, err := GetAppComposeConfig(a.Recipe.Name, opts, a.Env)
if err != nil {
return filters, err
}
@ -207,7 +206,7 @@ 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 {
if a[i].Server == a[j].Server {
return strings.ToLower(a[i].Recipe) < strings.ToLower(a[j].Recipe)
return strings.ToLower(a[i].Recipe.Name) < strings.ToLower(a[j].Recipe.Name)
}
return strings.ToLower(a[i].Server) < strings.ToLower(a[j].Server)
}
@ -218,7 +217,7 @@ type ByRecipe []App
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)
return strings.ToLower(a[i].Recipe.Name) < strings.ToLower(a[j].Recipe.Name)
}
// ByName sort a slice of Apps
@ -250,9 +249,9 @@ func ReadAppEnvFile(appFile AppFile, name AppName) (App, error) {
func NewApp(env envfile.AppEnv, name string, appFile AppFile) (App, error) {
domain := env["DOMAIN"]
recipe, exists := env["RECIPE"]
recipeName, exists := env["RECIPE"]
if !exists {
recipe, exists = env["TYPE"]
recipeName, exists = env["TYPE"]
if !exists {
return App{}, fmt.Errorf("%s is missing the TYPE env var?", name)
}
@ -261,7 +260,7 @@ func NewApp(env envfile.AppEnv, name string, appFile AppFile) (App, error) {
return App{
Name: name,
Domain: domain,
Recipe: recipe,
Recipe: recipe.Get2(recipeName),
Env: env,
Server: appFile.Server,
Path: appFile.Path,
@ -318,14 +317,13 @@ func GetAppServiceNames(appName string) ([]string, error) {
return serviceNames, err
}
r := recipe.Get2(app.Recipe)
composeFiles, err := r.GetComposeFiles(app.Env)
composeFiles, err := app.Recipe.GetComposeFiles(app.Env)
if err != nil {
return serviceNames, err
}
opts := stack.Deploy{Composefiles: composeFiles}
compose, err := GetAppComposeConfig(app.Recipe, opts, app.Env)
compose, err := GetAppComposeConfig(app.Recipe.Name, opts, app.Env)
if err != nil {
return serviceNames, err
}
@ -512,8 +510,7 @@ func ExposeAllEnv(stackName string, compose *composetypes.Config, appEnv envfile
func CheckEnv(app App) ([]envfile.EnvVar, error) {
var envVars []envfile.EnvVar
r := recipe.Get2(app.Recipe)
envSample, err := r.SampleEnv()
envSample, err := app.Recipe.SampleEnv()
if err != nil {
return envVars, err
}

8
pkg/app/app_test.go
View File

@ -47,8 +47,8 @@ func TestGetApp(t *testing.T) {
}
func TestGetComposeFiles(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}
@ -95,8 +95,8 @@ func TestGetComposeFiles(t *testing.T) {
}
func TestGetComposeFilesError(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}

31
pkg/envfile/envfile_test.go
View File

@ -55,8 +55,8 @@ func TestReadEnv(t *testing.T) {
}
func TestReadAbraShEnvVars(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}
@ -85,8 +85,8 @@ func TestReadAbraShEnvVars(t *testing.T) {
}
func TestReadAbraShCmdNames(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}
@ -110,8 +110,8 @@ func TestReadAbraShCmdNames(t *testing.T) {
}
func TestCheckEnv(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}
@ -124,7 +124,7 @@ func TestCheckEnv(t *testing.T) {
app := appPkg.App{
Name: "test-app",
Recipe: r.Name,
Recipe: recipe.Get2(r.Name),
Domain: "example.com",
Env: envSample,
Path: "example.com.env",
@ -144,8 +144,8 @@ func TestCheckEnv(t *testing.T) {
}
func TestCheckEnvError(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}
@ -160,7 +160,7 @@ func TestCheckEnvError(t *testing.T) {
app := appPkg.App{
Name: "test-app",
Recipe: r.Name,
Recipe: recipe.Get2(r.Name),
Domain: "example.com",
Env: envSample,
Path: "example.com.env",
@ -180,8 +180,8 @@ func TestCheckEnvError(t *testing.T) {
}
func TestEnvVarCommentsRemoved(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}
@ -212,14 +212,13 @@ func TestEnvVarCommentsRemoved(t *testing.T) {
}
func TestEnvVarModifiersIncluded(t *testing.T) {
offline := true
r, err := recipe.Get("abra-test-recipe", offline)
r := recipe.Get2("abra-test-recipe")
err := r.EnsureExists()
if err != nil {
t.Fatal(err)
}
r2 := recipe.Get2(r.Name)
envSample, modifiers, err := envfile.ReadEnvWithModifiers(r2.SampleEnvPath)
envSample, modifiers, err := envfile.ReadEnvWithModifiers(r.SampleEnvPath)
if err != nil {
t.Fatal(err)
}

3
pkg/test/test.go
View File

@ -7,6 +7,7 @@ import (
appPkg "coopcloud.tech/abra/pkg/app"
"coopcloud.tech/abra/pkg/envfile"
"coopcloud.tech/abra/pkg/log"
"coopcloud.tech/abra/pkg/recipe"
)
var (
@ -32,7 +33,7 @@ var ExpectedAppEnv = envfile.AppEnv{
var ExpectedApp = appPkg.App{
Name: AppName,
Recipe: ExpectedAppEnv["RECIPE"],
Recipe: recipe.Get2(ExpectedAppEnv["RECIPE"]),
Domain: ExpectedAppEnv["DOMAIN"],
Env: ExpectedAppEnv,
Path: ExpectedAppFile.Path,