From ef108d63e1526b300bd7fbc2a700cb2addf50ba1 Mon Sep 17 00:00:00 2001 From: decentral1se Date: Sun, 7 Jul 2024 23:45:37 +0200 Subject: [PATCH] refactor: use central logger --- cli/app/backup.go | 72 +++++++++++----------- cli/app/check.go | 12 ++-- cli/app/cmd.go | 52 ++++++++-------- cli/app/config.go | 10 +-- cli/app/cp.go | 18 +++--- cli/app/deploy.go | 82 ++++++++++++------------- cli/app/errors.go | 28 ++++----- cli/app/list.go | 20 +++--- cli/app/logs.go | 18 +++--- cli/app/new.go | 38 ++++++------ cli/app/ps.go | 18 +++--- cli/app/remove.go | 35 +++++------ cli/app/restart.go | 30 ++++----- cli/app/restore.go | 20 +++--- cli/app/rollback.go | 64 +++++++++---------- cli/app/run.go | 10 +-- cli/app/secret.go | 80 ++++++++++++------------ cli/app/services.go | 12 ++-- cli/app/undeploy.go | 26 ++++---- cli/app/upgrade.go | 80 ++++++++++++------------ cli/app/version.go | 18 +++--- cli/app/volume.go | 27 ++++---- cli/catalogue/catalogue.go | 46 +++++++------- cli/cli.go | 22 +++---- cli/internal/backup.go | 6 +- cli/internal/cli.go | 9 +-- cli/internal/command.go | 10 +-- cli/internal/deploy.go | 12 ++-- cli/internal/errors.go | 6 +- cli/internal/recipe.go | 6 +- cli/internal/validate.go | 32 +++++----- cli/recipe/diff.go | 4 +- cli/recipe/fetch.go | 8 +-- cli/recipe/lint.go | 16 ++--- cli/recipe/list.go | 4 +- cli/recipe/new.go | 18 +++--- cli/recipe/release.go | 76 +++++++++++------------ cli/recipe/reset.go | 10 +-- cli/recipe/sync.go | 46 +++++++------- cli/recipe/upgrade.go | 76 +++++++++++------------ cli/recipe/version.go | 8 +-- cli/server/add.go | 42 ++++++------- cli/server/list.go | 10 +-- cli/server/prune.go | 22 +++---- cli/server/remove.go | 8 +-- cli/updater/updater.go | 54 ++++++++-------- go.mod | 14 +++-- go.sum | 22 +++++-- pkg/app/app.go | 24 ++++---- pkg/app/compose.go | 16 ++--- pkg/autocomplete/autocomplete.go | 10 +-- pkg/catalogue/catalogue.go | 10 +-- pkg/client/client.go | 4 +- pkg/client/context.go | 4 +- pkg/client/volumes.go | 4 +- pkg/compose/compose.go | 22 +++---- pkg/config/abra.go | 16 ++--- pkg/config/env.go | 10 +-- pkg/container/container.go | 6 +- pkg/envfile/envfile.go | 10 +-- pkg/formatter/formatter.go | 4 +- pkg/git/add.go | 4 +- pkg/git/branch.go | 6 +- pkg/git/clone.go | 10 +-- pkg/git/commit.go | 6 +- pkg/git/diff.go | 4 +- pkg/git/init.go | 6 +- pkg/git/push.go | 8 +-- pkg/git/read.go | 12 ++-- pkg/git/remote.go | 4 +- pkg/lint/recipe.go | 16 ++--- pkg/recipe/recipe.go | 58 ++++++++--------- pkg/secret/pass.go | 10 +-- pkg/secret/secret.go | 18 +++--- pkg/server/server.go | 6 +- pkg/service/service.go | 10 +-- pkg/test/test.go | 7 +-- pkg/upstream/commandconn/commandconn.go | 24 ++++---- pkg/upstream/container/exec.go | 4 +- pkg/upstream/container/hijack.go | 14 ++--- pkg/upstream/container/tty.go | 4 +- pkg/upstream/service/scale.go | 4 +- pkg/upstream/stack/loader.go | 6 +- pkg/upstream/stack/remove.go | 20 +++--- pkg/upstream/stack/stack.go | 26 ++++---- pkg/web/client.go | 8 +-- 86 files changed, 903 insertions(+), 889 deletions(-) diff --git a/cli/app/backup.go b/cli/app/backup.go index f6c8d2ae2..c7067941b 100644 --- a/cli/app/backup.go +++ b/cli/app/backup.go @@ -6,8 +6,8 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -48,47 +48,47 @@ var appBackupListCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } targetContainer, err := internal.RetrieveBackupBotContainer(cl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)} if snapshot != "" { - logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) + log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot)) } if includePath != "" { - logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath) + log.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath) execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath)) } if err := internal.RunBackupCmdRemote(cl, "ls", targetContainer.ID, execEnv); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -111,53 +111,53 @@ var appBackupDownloadCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } targetContainer, err := internal.RetrieveBackupBotContainer(cl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)} if snapshot != "" { - logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) + log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot)) } if includePath != "" { - logrus.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath) + log.Debugf("including INCLUDE_PATH=%s in backupbot exec invocation", includePath) execEnv = append(execEnv, fmt.Sprintf("INCLUDE_PATH=%s", includePath)) } if err := internal.RunBackupCmdRemote(cl, "download", targetContainer.ID, execEnv); err != nil { - logrus.Fatal(err) + log.Fatal(err) } remoteBackupDir := "/tmp/backup.tar.gz" currentWorkingDir := "." if err = CopyFromContainer(cl, targetContainer.ID, remoteBackupDir, currentWorkingDir); err != nil { - logrus.Fatal(err) + log.Fatal(err) } fmt.Println("backup successfully downloaded to current working directory") @@ -181,43 +181,43 @@ var appBackupCreateCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } targetContainer, err := internal.RetrieveBackupBotContainer(cl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)} if resticRepo != "" { - logrus.Debugf("including RESTIC_REPO=%s in backupbot exec invocation", resticRepo) + log.Debugf("including RESTIC_REPO=%s in backupbot exec invocation", resticRepo) execEnv = append(execEnv, fmt.Sprintf("RESTIC_REPO=%s", resticRepo)) } if err := internal.RunBackupCmdRemote(cl, "create", targetContainer.ID, execEnv); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -239,43 +239,43 @@ var appBackupSnapshotsCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } targetContainer, err := internal.RetrieveBackupBotContainer(cl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)} if snapshot != "" { - logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) + log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot)) } if err := internal.RunBackupCmdRemote(cl, "snapshots", targetContainer.ID, execEnv); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil diff --git a/cli/app/check.go b/cli/app/check.go index ec95f8a44..53f689011 100644 --- a/cli/app/check.go +++ b/cli/app/check.go @@ -5,9 +5,9 @@ import ( appPkg "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" recipePkg "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -39,22 +39,22 @@ ${FOO:} syntax). "check" does not confirm or deny this for you.`, app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipePkg.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipePkg.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -63,7 +63,7 @@ ${FOO:} syntax). "check" does not confirm or deny this for you.`, envVars, err := appPkg.CheckEnv(app) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, envVar := range envVars { diff --git a/cli/app/cmd.go b/cli/app/cmd.go index 416812cbc..c8215d28e 100644 --- a/cli/app/cmd.go +++ b/cli/app/cmd.go @@ -15,9 +15,9 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/config" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" recipePkg "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -62,22 +62,22 @@ Example: app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipePkg.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipePkg.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -90,9 +90,9 @@ Example: abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh") if _, err := os.Stat(abraSh); err != nil { if os.IsNotExist(err) { - logrus.Fatalf("%s does not exist for %s?", abraSh, app.Name) + log.Fatalf("%s does not exist for %s?", abraSh, app.Name) } - logrus.Fatal(err) + log.Fatal(err) } if internal.LocalCmd { @@ -102,10 +102,10 @@ Example: cmdName := c.Args().Get(1) if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("--local detected, running %s on local work station", cmdName) + log.Debugf("--local detected, running %s on local work station", cmdName) var exportEnv string for k, v := range app.Env { @@ -114,22 +114,22 @@ Example: var sourceAndExec string if hasCmdArgs { - logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs) + log.Debugf("parsed following command arguments: %s", parsedCmdArgs) sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName, parsedCmdArgs) } else { - logrus.Debug("did not detect any command arguments") + log.Debug("did not detect any command arguments") sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName) } shell := "/bin/bash" if _, err := os.Stat(shell); errors.Is(err, os.ErrNotExist) { - logrus.Debugf("%s does not exist locally, use /bin/sh as fallback", shell) + log.Debugf("%s does not exist locally, use /bin/sh as fallback", shell) shell = "/bin/sh" } cmd := exec.Command(shell, "-c", sourceAndExec) if err := internal.RunCmd(cmd); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { if !(len(c.Args()) >= 3) { @@ -140,12 +140,12 @@ Example: cmdName := c.Args().Get(2) if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } serviceNames, err := appPkg.GetAppServiceNames(app.Name) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } matchingServiceName := false @@ -156,24 +156,24 @@ Example: } if !matchingServiceName { - logrus.Fatalf("no service %s for %s?", targetServiceName, app.Name) + log.Fatalf("no service %s for %s?", targetServiceName, app.Name) } - logrus.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName) + log.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName) if hasCmdArgs { - logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs) + log.Debugf("parsed following command arguments: %s", parsedCmdArgs) } else { - logrus.Debug("did not detect any command arguments") + log.Debug("did not detect any command arguments") } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := internal.RunCmdRemote(cl, app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -230,28 +230,28 @@ var appCmdListCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipePkg.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipePkg.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } cmdNames, err := getShCmdNames(app) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, cmdName := range cmdNames { diff --git a/cli/app/config.go b/cli/app/config.go index 7dd15eb25..11322703d 100644 --- a/cli/app/config.go +++ b/cli/app/config.go @@ -8,8 +8,8 @@ import ( "coopcloud.tech/abra/cli/internal" appPkg "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/autocomplete" + "coopcloud.tech/abra/pkg/log" "github.com/AlecAivazis/survey/v2" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -32,12 +32,12 @@ var appConfigCommand = cli.Command{ files, err := appPkg.LoadAppFiles("") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } appFile, exists := files[appName] if !exists { - logrus.Fatalf("cannot find app with name %s", appName) + log.Fatalf("cannot find app with name %s", appName) } ed, ok := os.LookupEnv("EDITOR") @@ -47,7 +47,7 @@ var appConfigCommand = cli.Command{ Options: []string{"vi", "vim", "nvim", "nano", "pico", "emacs"}, } if err := survey.AskOne(edPrompt, &ed); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -56,7 +56,7 @@ var appConfigCommand = cli.Command{ cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Run(); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil diff --git a/cli/app/cp.go b/cli/app/cp.go index f27b42ce1..f1c50d2a5 100644 --- a/cli/app/cp.go +++ b/cli/app/cp.go @@ -15,13 +15,13 @@ import ( "coopcloud.tech/abra/pkg/client" containerPkg "coopcloud.tech/abra/pkg/container" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/upstream/container" "github.com/docker/cli/cli/command" "github.com/docker/docker/api/types" dockerClient "github.com/docker/docker/client" "github.com/docker/docker/errdefs" "github.com/docker/docker/pkg/archive" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -53,27 +53,27 @@ And if you want to copy that file back to your current working directory locally src := c.Args().Get(1) dst := c.Args().Get(2) if src == "" { - logrus.Fatal("missing argument") + log.Fatal("missing argument") } if dst == "" { - logrus.Fatal("missing argument") + log.Fatal("missing argument") } srcPath, dstPath, service, toContainer, err := parseSrcAndDst(src, dst) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } container, err := containerPkg.GetContainerFromStackAndService(cl, app.StackName(), service) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server) + log.Debugf("retrieved %s as target container on %s", formatter.ShortenID(container.ID), app.Server) if toContainer { err = CopyToContainer(cl, container.ID, srcPath, dstPath) @@ -81,7 +81,7 @@ And if you want to copy that file back to your current working directory locally err = CopyFromContainer(cl, container.ID, srcPath, dstPath) } if err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -167,7 +167,7 @@ func CopyToContainer(cl *dockerClient.Client, containerID, srcPath, dstPath stri return err } - logrus.Debugf("copy %s from local to %s on container", srcPath, dstPath) + log.Debugf("copy %s from local to %s on container", srcPath, dstPath) copyOpts := types.CopyToContainerOptions{AllowOverwriteDirWithFile: false, CopyUIDGID: false} if err := cl.CopyToContainer(context.Background(), containerID, dstPath, content, copyOpts); err != nil { return err diff --git a/cli/app/deploy.go b/cli/app/deploy.go index 069251992..e7c3d5fd6 100644 --- a/cli/app/deploy.go +++ b/cli/app/deploy.go @@ -16,9 +16,9 @@ import ( "coopcloud.tech/abra/pkg/formatter" "coopcloud.tech/abra/pkg/git" "coopcloud.tech/abra/pkg/lint" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" "coopcloud.tech/abra/pkg/upstream/stack" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -55,48 +55,48 @@ recipes. specificVersion := c.Args().Get(1) if specificVersion != "" && internal.Chaos { - logrus.Fatal("cannot use and --chaos together") + log.Fatal("cannot use and --chaos together") } if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } r, err := recipe.Get(app.Recipe, internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := lint.LintForErrors(r); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("checking whether %s is already deployed", stackName) + log.Debugf("checking whether %s is already deployed", stackName) cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } // NOTE(d1): check out specific version before dealing with secrets. This @@ -106,46 +106,46 @@ recipes. version := deployedVersion if specificVersion != "" { version = specificVersion - logrus.Debugf("choosing %s as version to deploy", version) + log.Debugf("choosing %s as version to deploy", version) if err := recipe.EnsureVersion(app.Recipe, version); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } secStats, err := secret.PollSecretsStatus(cl, app) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, secStat := range secStats { if !secStat.CreatedOnRemote { - logrus.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName) + log.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName) } } if isDeployed { if internal.Force || internal.Chaos { - logrus.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name) + log.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name) } else { - logrus.Fatalf("%s is already deployed", app.Name) + log.Fatalf("%s is already deployed", app.Name) } } if !internal.Chaos && specificVersion == "" { catl, err := recipe.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if len(versions) == 0 && !internal.Chaos { - logrus.Warn("no published versions in catalogue, trying local recipe repository") + log.Warn("no published versions in catalogue, trying local recipe repository") recipeVersions, err := recipe.GetRecipeVersions(app.Recipe, internal.Offline) if err != nil { - logrus.Warn(err) + log.Warn(err) } for _, recipeVersion := range recipeVersions { for version := range recipeVersion { @@ -156,33 +156,33 @@ recipes. if len(versions) > 0 && !internal.Chaos { version = versions[len(versions)-1] - logrus.Debugf("choosing %s as version to deploy", version) + log.Debugf("choosing %s as version to deploy", version) if err := recipe.EnsureVersion(app.Recipe, version); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { head, err := git.GetRecipeHead(app.Recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } version = formatter.SmallSHA(head.String()) - logrus.Warn("no versions detected, using latest commit") + log.Warn("no versions detected, using latest commit") } } if internal.Chaos { - logrus.Warnf("chaos mode engaged") + log.Warnf("chaos mode engaged") var err error version, err = recipe.ChaosVersion(app.Recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh") abraShEnv, err := envfile.ReadAbraShEnvVars(abraShPath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for k, v := range abraShEnv { app.Env[k] = v @@ -190,7 +190,7 @@ recipes. composeFiles, err := recipe.GetComposeFiles(app.Recipe, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } deployOpts := stack.Deploy{ @@ -202,7 +202,7 @@ recipes. } compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } appPkg.ExposeAllEnv(stackName, compose, app.Env) @@ -213,47 +213,47 @@ recipes. envVars, err := appPkg.CheckEnv(app) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, envVar := range envVars { if !envVar.Present { - logrus.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain) + log.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain) } } if err := internal.DeployOverview(app, version, "continue with deployment?"); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.NoDomainChecks { domainName, ok := app.Env["DOMAIN"] if ok { if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { - logrus.Warn("skipping domain checks as no DOMAIN=... configured for app") + log.Warn("skipping domain checks as no DOMAIN=... configured for app") } } else { - logrus.Warn("skipping domain checks as requested") + log.Warn("skipping domain checks as requested") } stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("set waiting timeout to %d s", stack.WaitTimeout) + log.Debugf("set waiting timeout to %d s", stack.WaitTimeout) if err := stack.RunDeploy(cl, deployOpts, compose, app.Name, internal.DontWaitConverge); err != nil { - logrus.Fatal(err) + log.Fatal(err) } postDeployCmds, ok := app.Env["POST_DEPLOY_CMDS"] if ok && !internal.DontWaitConverge { - logrus.Debugf("run the following post-deploy commands: %s", postDeployCmds) + log.Debugf("run the following post-deploy commands: %s", postDeployCmds) if err := internal.PostCmds(cl, app, postDeployCmds); err != nil { - logrus.Fatalf("attempting to run post deploy commands, saw: %s", err) + log.Fatalf("attempting to run post deploy commands, saw: %s", err) } } return nil diff --git a/cli/app/errors.go b/cli/app/errors.go index a3fb974d3..c544fb9ca 100644 --- a/cli/app/errors.go +++ b/cli/app/errors.go @@ -11,12 +11,12 @@ import ( appPkg "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" stack "coopcloud.tech/abra/pkg/upstream/stack" containerTypes "github.com/docker/docker/api/types/container" "github.com/docker/docker/api/types/filters" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -59,28 +59,28 @@ the logs. cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } if !internal.Watch { if err := checkErrors(c, cl, app); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil } for { if err := checkErrors(c, cl, app); err != nil { - logrus.Fatal(err) + log.Fatal(err) } time.Sleep(2 * time.Second) } @@ -103,30 +103,30 @@ func checkErrors(c *cli.Context, cl *dockerClient.Client, app appPkg.App) error } if len(containers) == 0 { - logrus.Warnf("%s is not up, something seems wrong", service.Name) + log.Warnf("%s is not up, something seems wrong", service.Name) continue } container := containers[0] containerState, err := cl.ContainerInspect(context.Background(), container.ID) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if containerState.State.OOMKilled { - logrus.Warnf("%s has been killed due to an out of memory error", service.Name) + log.Warnf("%s has been killed due to an out of memory error", service.Name) } if containerState.State.Error != "" { - logrus.Warnf("%s reports this error: %s", service.Name, containerState.State.Error) + log.Warnf("%s reports this error: %s", service.Name, containerState.State.Error) } if containerState.State.Health != nil { if containerState.State.Health.Status != "healthy" { - logrus.Warnf("%s healthcheck status is %s", service.Name, containerState.State.Health.Status) - logrus.Warnf("%s healthcheck has failed %s times", service.Name, strconv.Itoa(containerState.State.Health.FailingStreak)) - for _, log := range containerState.State.Health.Log { - logrus.Warnf("%s healthcheck logs: %s", service.Name, strings.TrimSpace(log.Output)) + log.Warnf("%s healthcheck status is %s", service.Name, containerState.State.Health.Status) + log.Warnf("%s healthcheck has failed %s times", service.Name, strconv.Itoa(containerState.State.Health.FailingStreak)) + for _, entry := range containerState.State.Health.Log { + log.Warnf("%s healthcheck logs: %s", service.Name, strings.TrimSpace(entry.Output)) } } } diff --git a/cli/app/list.go b/cli/app/list.go index 63fab5bc3..422461e33 100644 --- a/cli/app/list.go +++ b/cli/app/list.go @@ -10,9 +10,9 @@ import ( "coopcloud.tech/abra/cli/internal" appPkg "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" "coopcloud.tech/tagcmp" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -85,12 +85,12 @@ can take some time. Action: func(c *cli.Context) error { appFiles, err := appPkg.LoadAppFiles(listAppServer) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } apps, err := appPkg.GetApps(appFiles, recipeFilter) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } sort.Sort(appPkg.ByServerAndRecipe(apps)) @@ -107,12 +107,12 @@ can take some time. statuses, err = appPkg.GetAppStatuses(apps, internal.MachineReadable) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } catl, err = recipe.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -179,18 +179,18 @@ can take some time. if version != "unknown" { updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } parsedVersion, err := tagcmp.Parse(version) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, update := range updates { parsedUpdate, err := tagcmp.Parse(update) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if update != version && parsedUpdate.IsGreaterThan(parsedVersion) { @@ -226,7 +226,7 @@ can take some time. if internal.MachineReadable { jsonstring, err := json.Marshal(allStats) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } else { fmt.Println(string(jsonstring)) } @@ -255,7 +255,7 @@ can take some time. if chaosStatus != "unknown" { chaosEnabled, err := strconv.ParseBool(chaosStatus) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if chaosEnabled && appStat.ChaosVersion != "unknown" { chaosStatus = appStat.ChaosVersion diff --git a/cli/app/logs.go b/cli/app/logs.go index e03ba07bf..c98d62b57 100644 --- a/cli/app/logs.go +++ b/cli/app/logs.go @@ -12,6 +12,7 @@ import ( appPkg "coopcloud.tech/abra/pkg/app" "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" @@ -19,7 +20,6 @@ import ( "github.com/docker/docker/api/types/filters" "github.com/docker/docker/api/types/swarm" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -40,21 +40,21 @@ var appLogsCommand = cli.Command{ stackName := app.StackName() if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, _, err := stack.IsDeployed(context.Background(), cl, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } serviceName := c.Args().Get(1) @@ -64,7 +64,7 @@ var appLogsCommand = cli.Command{ } err = tailLogs(cl, app, serviceNames) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -102,7 +102,7 @@ func tailLogs(cl *dockerClient.Client, app appPkg.App, serviceNames []string) er lastTask := tasks[0].Status if lastTask.State != swarm.TaskStateRunning { for _, task := range tasks { - logrus.Errorf("[%s] %s State %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err) + log.Errorf("[%s] %s State %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err) } } } @@ -122,13 +122,13 @@ func tailLogs(cl *dockerClient.Client, app appPkg.App, serviceNames []string) er Details: false, }) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } defer logs.Close() _, err = io.Copy(os.Stdout, logs) if err != nil && err != io.EOF { - logrus.Fatal(err) + log.Fatal(err) } }(service.ID) } diff --git a/cli/app/new.go b/cli/app/new.go index 395ec2d0a..5011af63d 100644 --- a/cli/app/new.go +++ b/cli/app/new.go @@ -11,11 +11,11 @@ import ( "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/formatter" "coopcloud.tech/abra/pkg/jsontable" + "coopcloud.tech/abra/pkg/log" recipePkg "coopcloud.tech/abra/pkg/recipe" "coopcloud.tech/abra/pkg/secret" "github.com/AlecAivazis/survey/v2" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -70,11 +70,11 @@ var appNewCommand = cli.Command{ if !internal.Chaos { if err := recipePkg.EnsureIsClean(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if c.Args().Get(1) == "" { @@ -82,7 +82,7 @@ var appNewCommand = cli.Command{ recipeVersions, err := recipePkg.GetRecipeVersions(recipe.Name, internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } // NOTE(d1): determine whether recipe versions exist or not and check @@ -94,30 +94,30 @@ var appNewCommand = cli.Command{ } if err := recipePkg.EnsureVersion(recipe.Name, version); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { if err := recipePkg.EnsureLatest(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } } else { if err := recipePkg.EnsureVersion(recipe.Name, c.Args().Get(1)); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } } if err := ensureServerFlag(); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := ensureDomainFlag(recipe, internal.NewAppServer); err != nil { - logrus.Fatal(err) + log.Fatal(err) } sanitisedAppName := appPkg.SanitiseAppName(internal.Domain) - logrus.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName) + log.Debugf("%s sanitised as %s for new app", internal.Domain, sanitisedAppName) if err := appPkg.TemplateAppEnvSample( recipe.Name, @@ -125,7 +125,7 @@ var appNewCommand = cli.Command{ internal.NewAppServer, internal.Domain, ); err != nil { - logrus.Fatal(err) + log.Fatal(err) } var secrets AppSecrets @@ -133,12 +133,12 @@ var appNewCommand = cli.Command{ if internal.Secrets { sampleEnv, err := recipe.SampleEnv() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } composeFiles, err := recipePkg.GetComposeFiles(recipe.Name, sampleEnv) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } envSamplePath := path.Join(config.RECIPES_DIR, recipe.Name, ".env.sample") @@ -148,17 +148,17 @@ var appNewCommand = cli.Command{ } if err := promptForSecrets(recipe.Name, secretsConfig); err != nil { - logrus.Fatal(err) + log.Fatal(err) } cl, err := client.New(internal.NewAppServer) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secrets, err = createSecrets(cl, secretsConfig, sanitisedAppName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secretCols := []string{"Name", "Value"} @@ -191,7 +191,7 @@ var appNewCommand = cli.Command{ fmt.Println("Here are your generated secrets:") fmt.Println("") secretTable.Render() - logrus.Warn("generated secrets are not shown again, please take note of them NOW") + log.Warn("generated secrets are not shown again, please take note of them NOW") } return nil @@ -205,7 +205,7 @@ type AppSecrets map[string]string func createSecrets(cl *dockerClient.Client, secretsConfig map[string]secret.Secret, sanitisedAppName string) (AppSecrets, error) { // NOTE(d1): trim to match app.StackName() implementation if len(sanitisedAppName) > config.MAX_SANITISED_APP_NAME_LENGTH { - logrus.Debugf("trimming %s to %s to avoid runtime limits", sanitisedAppName, sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH]) + log.Debugf("trimming %s to %s to avoid runtime limits", sanitisedAppName, sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH]) sanitisedAppName = sanitisedAppName[:config.MAX_SANITISED_APP_NAME_LENGTH] } @@ -253,7 +253,7 @@ func ensureDomainFlag(recipe recipePkg.Recipe, server string) error { // promptForSecrets asks if we should generate secrets for a new app. func promptForSecrets(recipeName string, secretsConfig map[string]secret.Secret) error { if len(secretsConfig) == 0 { - logrus.Debugf("%s has no secrets to generate, skipping...", recipeName) + log.Debugf("%s has no secrets to generate, skipping...", recipeName) return nil } diff --git a/cli/app/ps.go b/cli/app/ps.go index 1e88302a7..f42118922 100644 --- a/cli/app/ps.go +++ b/cli/app/ps.go @@ -11,6 +11,7 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" abraService "coopcloud.tech/abra/pkg/service" stack "coopcloud.tech/abra/pkg/upstream/stack" @@ -19,7 +20,6 @@ import ( containerTypes "github.com/docker/docker/api/types/container" "github.com/docker/docker/api/types/filters" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -41,23 +41,23 @@ var appPsCommand = cli.Command{ cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } statuses, err := appPkg.GetAppStatuses([]appPkg.App{app}, true) if statusMeta, ok := statuses[app.StackName()]; ok { if _, exists := statusMeta["chaos"]; !exists { if err := recipe.EnsureVersion(app.Recipe, deployedVersion); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } } @@ -81,7 +81,7 @@ var appPsCommand = cli.Command{ func showPSOutput(app appPkg.App, cl *dockerClient.Client) { composeFiles, err := recipe.GetComposeFiles(app.Recipe, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) return } @@ -93,7 +93,7 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client) { } compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) return } @@ -105,7 +105,7 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client) { containers, err := cl.ContainerList(context.Background(), containerTypes.ListOptions{Filters: filters}) if err != nil { - logrus.Fatal(err) + log.Fatal(err) return } @@ -148,7 +148,7 @@ func showPSOutput(app appPkg.App, cl *dockerClient.Client) { if internal.MachineReadable { jsonstring, err := json.Marshal(allContainerStats) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } fmt.Println(string(jsonstring)) diff --git a/cli/app/remove.go b/cli/app/remove.go index f9167d823..fb15c8611 100644 --- a/cli/app/remove.go +++ b/cli/app/remove.go @@ -3,16 +3,15 @@ package app import ( "context" "fmt" - "log" "os" "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" + "coopcloud.tech/abra/pkg/log" stack "coopcloud.tech/abra/pkg/upstream/stack" "github.com/AlecAivazis/survey/v2" "github.com/docker/docker/api/types" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -55,34 +54,34 @@ flag. msg := "ALERTA ALERTA: this will completely remove %s data and configurations locally and remotely, are you sure?" prompt := &survey.Confirm{Message: fmt.Sprintf(msg, app.Name)} if err := survey.AskOne(prompt, &response); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !response { - logrus.Fatal("aborting as requested") + log.Fatal("aborting as requested") } } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if isDeployed { - logrus.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name) + log.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name) } fs, err := app.Filters(false, false) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: fs}) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secrets := make(map[string]string) @@ -97,22 +96,22 @@ flag. for _, name := range secretNames { err := cl.SecretRemove(context.Background(), secrets[name]) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Info(fmt.Sprintf("secret: %s removed", name)) + log.Info(fmt.Sprintf("secret: %s removed", name)) } } else { - logrus.Info("no secrets to remove") + log.Info("no secrets to remove") } fs, err = app.Filters(false, true) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, fs) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } volumeNames := client.GetVolumeNames(volumeList) @@ -122,16 +121,16 @@ flag. log.Fatalf("removing volumes failed: %s", err) } - logrus.Infof("%d volumes removed successfully", len(volumeNames)) + log.Infof("%d volumes removed successfully", len(volumeNames)) } else { - logrus.Info("no volumes to remove") + log.Info("no volumes to remove") } if err = os.Remove(app.Path); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Info(fmt.Sprintf("file: %s removed", app.Path)) + log.Info(fmt.Sprintf("file: %s removed", app.Path)) return nil }, diff --git a/cli/app/restart.go b/cli/app/restart.go index d5ada1053..27c77abf6 100644 --- a/cli/app/restart.go +++ b/cli/app/restart.go @@ -9,9 +9,9 @@ import ( appPkg "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" + "coopcloud.tech/abra/pkg/log" upstream "coopcloud.tech/abra/pkg/upstream/service" stack "coopcloud.tech/abra/pkg/upstream/stack" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -48,7 +48,7 @@ Example: } if serviceName != "" && internal.AllServices { - logrus.Fatal("cannot use and --all-services together") + log.Fatal("cannot use and --all-services together") } var serviceNames []string @@ -56,7 +56,7 @@ Example: var err error serviceNames, err = appPkg.GetAppServiceNames(app.Name) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { serviceNames = append(serviceNames, serviceName) @@ -64,44 +64,44 @@ Example: cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } for _, serviceName := range serviceNames { stackServiceName := fmt.Sprintf("%s_%s", app.StackName(), serviceName) - logrus.Debugf("attempting to scale %s to 0", stackServiceName) + log.Debugf("attempting to scale %s to 0", stackServiceName) if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 0); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("%s has been scaled to 0", stackServiceName) - logrus.Debugf("attempting to scale %s to 1", stackServiceName) + log.Debugf("%s has been scaled to 0", stackServiceName) + log.Debugf("attempting to scale %s to 1", stackServiceName) if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 1); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("%s has been scaled to 1", stackServiceName) - logrus.Infof("%s service successfully restarted", serviceName) + log.Debugf("%s has been scaled to 1", stackServiceName) + log.Infof("%s service successfully restarted", serviceName) } return nil diff --git a/cli/app/restore.go b/cli/app/restore.go index c80347f53..f95b497d8 100644 --- a/cli/app/restore.go +++ b/cli/app/restore.go @@ -6,8 +6,8 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -34,47 +34,47 @@ var appRestoreCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } targetContainer, err := internal.RetrieveBackupBotContainer(cl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } execEnv := []string{fmt.Sprintf("SERVICE=%s", app.Domain)} if snapshot != "" { - logrus.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) + log.Debugf("including SNAPSHOT=%s in backupbot exec invocation", snapshot) execEnv = append(execEnv, fmt.Sprintf("SNAPSHOT=%s", snapshot)) } if targetPath != "" { - logrus.Debugf("including TARGET=%s in backupbot exec invocation", targetPath) + log.Debugf("including TARGET=%s in backupbot exec invocation", targetPath) execEnv = append(execEnv, fmt.Sprintf("TARGET=%s", targetPath)) } if err := internal.RunBackupCmdRemote(cl, "restore", targetContainer.ID, execEnv); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil diff --git a/cli/app/rollback.go b/cli/app/rollback.go index 4be20cf49..6dbf449c0 100644 --- a/cli/app/rollback.go +++ b/cli/app/rollback.go @@ -15,8 +15,8 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/client" + "coopcloud.tech/abra/pkg/log" "github.com/AlecAivazis/survey/v2" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -55,69 +55,69 @@ recipes. specificVersion := c.Args().Get(1) if specificVersion != "" && internal.Chaos { - logrus.Fatal("cannot use and --chaos together") + log.Fatal("cannot use and --chaos together") } if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } r, err := recipe.Get(app.Recipe, internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := lint.LintForErrors(r); err != nil { - logrus.Fatal(err) + log.Fatal(err) } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("checking whether %s is already deployed", stackName) + log.Debugf("checking whether %s is already deployed", stackName) isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } catl, err := recipe.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if len(versions) == 0 && !internal.Chaos { - logrus.Warn("no published versions in catalogue, trying local recipe repository") + log.Warn("no published versions in catalogue, trying local recipe repository") recipeVersions, err := recipe.GetRecipeVersions(app.Recipe, internal.Offline) if err != nil { - logrus.Warn(err) + log.Warn(err) } for _, recipeVersion := range recipeVersions { for version := range recipeVersion { @@ -129,20 +129,20 @@ recipes. var availableDowngrades []string if deployedVersion == "unknown" { availableDowngrades = versions - logrus.Warnf("failed to determine deployed version of %s", app.Name) + log.Warnf("failed to determine deployed version of %s", app.Name) } if specificVersion != "" { parsedDeployedVersion, err := tagcmp.Parse(deployedVersion) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } parsedSpecificVersion, err := tagcmp.Parse(specificVersion) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) { - logrus.Fatalf("%s is not a downgrade for %s?", deployedVersion, specificVersion) + log.Fatalf("%s is not a downgrade for %s?", deployedVersion, specificVersion) } availableDowngrades = append(availableDowngrades, specificVersion) } @@ -151,11 +151,11 @@ recipes. for _, version := range versions { parsedDeployedVersion, err := tagcmp.Parse(deployedVersion) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } parsedVersion, err := tagcmp.Parse(version) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if parsedVersion.IsLessThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) { availableDowngrades = append(availableDowngrades, version) @@ -163,7 +163,7 @@ recipes. } if len(availableDowngrades) == 0 && !internal.Force { - logrus.Info("no available downgrades, you're on oldest ✌️") + log.Info("no available downgrades, you're on oldest ✌️") return nil } } @@ -172,7 +172,7 @@ recipes. if len(availableDowngrades) > 0 && !internal.Chaos { if internal.Force || internal.NoInput || specificVersion != "" { chosenDowngrade = availableDowngrades[len(availableDowngrades)-1] - logrus.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade) + log.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade) } else { prompt := &survey.Select{ Message: fmt.Sprintf("Please select a downgrade (current version: %s):", deployedVersion), @@ -186,23 +186,23 @@ recipes. if !internal.Chaos { if err := recipe.EnsureVersion(app.Recipe, chosenDowngrade); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if internal.Chaos { - logrus.Warn("chaos mode engaged") + log.Warn("chaos mode engaged") var err error chosenDowngrade, err = recipe.ChaosVersion(app.Recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh") abraShEnv, err := envfile.ReadAbraShEnvVars(abraShPath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for k, v := range abraShEnv { app.Env[k] = v @@ -210,7 +210,7 @@ recipes. composeFiles, err := recipe.GetComposeFiles(app.Recipe, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } deployOpts := stack.Deploy{ Composefiles: composeFiles, @@ -221,7 +221,7 @@ recipes. } compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } appPkg.ExposeAllEnv(stackName, compose, app.Env) appPkg.SetRecipeLabel(compose, stackName, app.Recipe) @@ -231,11 +231,11 @@ recipes. // NOTE(d1): no release notes implemeneted for rolling back if err := internal.NewVersionOverview(app, deployedVersion, chosenDowngrade, ""); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil diff --git a/cli/app/run.go b/cli/app/run.go index b5e0a9ce2..6866659d4 100644 --- a/cli/app/run.go +++ b/cli/app/run.go @@ -9,11 +9,11 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" containerPkg "coopcloud.tech/abra/pkg/container" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/upstream/container" "github.com/docker/cli/cli/command" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -55,7 +55,7 @@ var appRunCommand = cli.Command{ cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } serviceName := c.Args().Get(1) @@ -65,7 +65,7 @@ var appRunCommand = cli.Command{ targetContainer, err := containerPkg.GetContainer(context.Background(), cl, filters, false) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } cmd := c.Args()[2:] @@ -88,11 +88,11 @@ var appRunCommand = cli.Command{ // FIXME: avoid instantiating a new CLI dcli, err := command.NewDockerCli() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil diff --git a/cli/app/secret.go b/cli/app/secret.go index 6f4b4a2eb..672496f17 100644 --- a/cli/app/secret.go +++ b/cli/app/secret.go @@ -13,11 +13,11 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "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" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -58,22 +58,22 @@ var appSecretGenerateCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -89,12 +89,12 @@ var appSecretGenerateCommand = cli.Command{ composeFiles, err := recipe.GetComposeFiles(app.Recipe, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secrets, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !allSecrets { @@ -102,7 +102,7 @@ var appSecretGenerateCommand = cli.Command{ secretVersion := c.Args().Get(2) s, ok := secrets[secretName] if !ok { - logrus.Fatalf("%s doesn't exist in the env config?", secretName) + log.Fatalf("%s doesn't exist in the env config?", secretName) } s.Version = secretVersion secrets = map[string]secret.Secret{ @@ -112,24 +112,24 @@ var appSecretGenerateCommand = cli.Command{ cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secretVals, err := secret.GenerateSecrets(cl, secrets, app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if internal.Pass { for name, data := range secretVals { if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } } if len(secretVals) == 0 { - logrus.Warn("no secrets generated") + log.Warn("no secrets generated") os.Exit(1) } @@ -144,7 +144,7 @@ var appSecretGenerateCommand = cli.Command{ } else { table.Render() } - logrus.Warn("generated secrets are not shown again, please take note of them NOW") + log.Warn("generated secrets are not shown again, please take note of them NOW") return nil }, @@ -184,7 +184,7 @@ Example: cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } name := c.Args().Get(1) @@ -194,7 +194,7 @@ Example: if internal.File { raw, err := os.ReadFile(data) if err != nil { - logrus.Fatalf("reading secret from file: %s", err) + log.Fatalf("reading secret from file: %s", err) } data = string(raw) } @@ -205,14 +205,14 @@ Example: secretName := fmt.Sprintf("%s_%s_%s", app.StackName(), name, version) if err := client.StoreSecret(cl, secretName, data, app.Server); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Infof("%s successfully stored on server", secretName) + log.Infof("%s successfully stored on server", secretName) if internal.Pass { if err := secret.PassInsertSecret(data, name, app.Name, app.Server); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -226,14 +226,14 @@ func secretRm(cl *dockerClient.Client, app appPkg.App, secretName, parsed string return err } - logrus.Infof("deleted %s successfully from server", secretName) + log.Infof("deleted %s successfully from server", secretName) if internal.PassRemove { if err := secret.PassRmSecret(parsed, app.StackName(), app.Server); err != nil { return err } - logrus.Infof("deleted %s successfully from local pass store", secretName) + log.Infof("deleted %s successfully from local pass store", secretName) } return nil @@ -265,33 +265,33 @@ Example: app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } composeFiles, err := recipe.GetComposeFiles(app.Recipe, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secrets, err := secret.ReadSecretsConfig(app.Path, composeFiles, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if c.Args().Get(1) != "" && rmAllSecrets { @@ -304,17 +304,17 @@ Example: cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } filters, err := app.Filters(false, false) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } secretList, err := cl.SecretList(context.Background(), types.SecretListOptions{Filters: filters}) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } remoteSecretNames := make(map[string]bool) @@ -330,7 +330,7 @@ Example: if secretToRm != "" { if secretName == secretToRm { if err := secretRm(cl, app, secretRemoteName, secretName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -339,18 +339,18 @@ Example: match = true if err := secretRm(cl, app, secretRemoteName, secretName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } } } if !match && secretToRm != "" { - logrus.Fatalf("%s doesn't exist on server?", secretToRm) + log.Fatalf("%s doesn't exist on server?", secretToRm) } if !match { - logrus.Fatal("no secrets to remove?") + log.Fatal("no secrets to remove?") } return nil @@ -373,28 +373,28 @@ var appSecretLsCommand = cli.Command{ app := internal.ValidateApp(c) if err := recipe.EnsureExists(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } tableCol := []string{"Name", "Version", "Generated Name", "Created On Server"} @@ -402,7 +402,7 @@ var appSecretLsCommand = cli.Command{ secStats, err := secret.PollSecretsStatus(cl, app) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, secStat := range secStats { @@ -422,7 +422,7 @@ var appSecretLsCommand = cli.Command{ table.Render() } } else { - logrus.Warnf("no secrets stored for %s", app.Name) + log.Warnf("no secrets stored for %s", app.Name) } return nil diff --git a/cli/app/services.go b/cli/app/services.go index 1f76077d0..60843d818 100644 --- a/cli/app/services.go +++ b/cli/app/services.go @@ -9,10 +9,10 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/service" stack "coopcloud.tech/abra/pkg/upstream/stack" containerTypes "github.com/docker/docker/api/types/container" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -31,26 +31,26 @@ var appServicesCommand = cli.Command{ cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } filters, err := app.Filters(true, true) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } containers, err := cl.ContainerList(context.Background(), containerTypes.ListOptions{Filters: filters}) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } tableCol := []string{"service name", "image"} diff --git a/cli/app/undeploy.go b/cli/app/undeploy.go index 7dce914f7..c0844b2eb 100644 --- a/cli/app/undeploy.go +++ b/cli/app/undeploy.go @@ -10,10 +10,10 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" stack "coopcloud.tech/abra/pkg/upstream/stack" "github.com/docker/docker/api/types/filters" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -33,7 +33,7 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app appPkg.App) error { ctx := context.Background() for { - logrus.Debugf("polling for %s stack, waiting to be undeployed...", stackName) + log.Debugf("polling for %s stack, waiting to be undeployed...", stackName) services, err := stack.GetStackServices(ctx, cl, stackName) if err != nil { @@ -41,7 +41,7 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app appPkg.App) error { } if len(services) == 0 { - logrus.Debugf("%s undeployed, moving on with pruning logic", stackName) + log.Debugf("%s undeployed, moving on with pruning logic", stackName) time.Sleep(time.Second) // give runtime more time to tear down related state break } @@ -58,14 +58,14 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app appPkg.App) error { } cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed) - logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed) + log.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed) nr, err := cl.NetworksPrune(ctx, pruneFilters) if err != nil { return err } - logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted)) + log.Infof("networks pruned: %d", len(nr.NetworksDeleted)) ir, err := cl.ImagesPrune(ctx, pruneFilters) if err != nil { @@ -73,7 +73,7 @@ func pruneApp(c *cli.Context, cl *dockerClient.Client, app appPkg.App) error { } imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed) - logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed) + log.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed) return nil } @@ -104,22 +104,22 @@ Passing "-p/--prune" does not remove those volumes. cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("checking whether %s is already deployed", stackName) + log.Debugf("checking whether %s is already deployed", stackName) isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } if err := internal.DeployOverview(app, deployedVersion, "continue with undeploy?"); err != nil { - logrus.Fatal(err) + log.Fatal(err) } rmOpts := stack.Remove{ @@ -127,12 +127,12 @@ Passing "-p/--prune" does not remove those volumes. Detach: false, } if err := stack.RunRemove(context.Background(), cl, rmOpts); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if prune { if err := pruneApp(c, cl, app); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } diff --git a/cli/app/upgrade.go b/cli/app/upgrade.go index 6079c5b15..4f54a4818 100644 --- a/cli/app/upgrade.go +++ b/cli/app/upgrade.go @@ -11,12 +11,12 @@ import ( "coopcloud.tech/abra/pkg/config" "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" "github.com/AlecAivazis/survey/v2" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -61,65 +61,65 @@ recipes. specificVersion := c.Args().Get(1) if specificVersion != "" && internal.Chaos { - logrus.Fatal("cannot use and --chaos together") + log.Fatal("cannot use and --chaos together") } if !internal.Chaos { if err := recipe.EnsureIsClean(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipe.EnsureUpToDate(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipe.EnsureLatest(app.Recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } recipe, err := recipePkg.Get(app.Recipe, internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := lint.LintForErrors(recipe); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("checking whether %s is already deployed", stackName) + log.Debugf("checking whether %s is already deployed", stackName) cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } versions, err := recipePkg.GetRecipeCatalogueVersions(app.Recipe, catl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if len(versions) == 0 && !internal.Chaos { - logrus.Warn("no published versions in catalogue, trying local recipe repository") + log.Warn("no published versions in catalogue, trying local recipe repository") recipeVersions, err := recipePkg.GetRecipeVersions(app.Recipe, internal.Offline) if err != nil { - logrus.Warn(err) + log.Warn(err) } for _, recipeVersion := range recipeVersions { for version := range recipeVersion { @@ -131,34 +131,34 @@ recipes. var availableUpgrades []string if deployedVersion == "unknown" { availableUpgrades = versions - logrus.Warnf("failed to determine deployed version of %s", app.Name) + log.Warnf("failed to determine deployed version of %s", app.Name) } if specificVersion != "" { parsedDeployedVersion, err := tagcmp.Parse(deployedVersion) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } parsedSpecificVersion, err := tagcmp.Parse(specificVersion) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if parsedSpecificVersion.IsLessThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) { - logrus.Fatalf("%s is not an upgrade for %s?", deployedVersion, specificVersion) + log.Fatalf("%s is not an upgrade for %s?", deployedVersion, specificVersion) } availableUpgrades = append(availableUpgrades, specificVersion) } parsedDeployedVersion, err := tagcmp.Parse(deployedVersion) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" { for _, version := range versions { parsedVersion, err := tagcmp.Parse(version) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if parsedVersion.IsGreaterThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) { availableUpgrades = append(availableUpgrades, version) @@ -166,7 +166,7 @@ recipes. } if len(availableUpgrades) == 0 && !internal.Force { - logrus.Infof("no available upgrades, you're on latest (%s) ✌️", deployedVersion) + log.Infof("no available upgrades, you're on latest (%s) ✌️", deployedVersion) return nil } } @@ -175,7 +175,7 @@ recipes. if len(availableUpgrades) > 0 && !internal.Chaos { if internal.Force || internal.NoInput || specificVersion != "" { chosenUpgrade = availableUpgrades[len(availableUpgrades)-1] - logrus.Debugf("choosing %s as version to upgrade to", chosenUpgrade) + log.Debugf("choosing %s as version to upgrade to", chosenUpgrade) } else { prompt := &survey.Select{ Message: fmt.Sprintf("Please select an upgrade (current version: %s):", deployedVersion), @@ -188,7 +188,7 @@ recipes. } if internal.Force && chosenUpgrade == "" { - logrus.Warnf("%s is already upgraded to latest but continuing (--force/--chaos)", app.Name) + log.Warnf("%s is already upgraded to latest but continuing (--force/--chaos)", app.Name) chosenUpgrade = deployedVersion } @@ -199,12 +199,12 @@ recipes. if chosenUpgrade != "" { parsedChosenUpgrade, err := tagcmp.Parse(chosenUpgrade) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, version := range versions { parsedVersion, err := tagcmp.Parse(version) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if parsedVersion.IsGreaterThan(parsedDeployedVersion) && parsedVersion.IsLessThan(parsedChosenUpgrade) { note, err := internal.GetReleaseNotes(app.Recipe, version) @@ -220,23 +220,23 @@ recipes. if !internal.Chaos { if err := recipePkg.EnsureVersion(app.Recipe, chosenUpgrade); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if internal.Chaos { - logrus.Warn("chaos mode engaged") + log.Warn("chaos mode engaged") var err error chosenUpgrade, err = recipePkg.ChaosVersion(app.Recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh") abraShEnv, err := envfile.ReadAbraShEnvVars(abraShPath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for k, v := range abraShEnv { app.Env[k] = v @@ -244,7 +244,7 @@ recipes. composeFiles, err := recipePkg.GetComposeFiles(app.Recipe, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } deployOpts := stack.Deploy{ Composefiles: composeFiles, @@ -255,7 +255,7 @@ recipes. } compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } appPkg.ExposeAllEnv(stackName, compose, app.Env) appPkg.SetRecipeLabel(compose, stackName, app.Recipe) @@ -265,12 +265,12 @@ recipes. envVars, err := appPkg.CheckEnv(app) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, envVar := range envVars { if !envVar.Present { - logrus.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain) + log.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain) } } @@ -281,24 +281,24 @@ recipes. } if err := internal.NewVersionOverview(app, deployedVersion, chosenUpgrade, releaseNotes); err != nil { - logrus.Fatal(err) + log.Fatal(err) } stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("set waiting timeout to %d s", stack.WaitTimeout) + log.Debugf("set waiting timeout to %d s", stack.WaitTimeout) if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil { - logrus.Fatal(err) + log.Fatal(err) } postDeployCmds, ok := app.Env["POST_UPGRADE_CMDS"] if ok && !internal.DontWaitConverge { - logrus.Debugf("run the following post-deploy commands: %s", postDeployCmds) + log.Debugf("run the following post-deploy commands: %s", postDeployCmds) if err := internal.PostCmds(cl, app, postDeployCmds); err != nil { - logrus.Fatalf("attempting to run post deploy commands, saw: %s", err) + log.Fatalf("attempting to run post deploy commands, saw: %s", err) } } diff --git a/cli/app/version.go b/cli/app/version.go index 437976aba..4c5b4667a 100644 --- a/cli/app/version.go +++ b/cli/app/version.go @@ -8,11 +8,11 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" "coopcloud.tech/abra/pkg/upstream/stack" "github.com/distribution/reference" "github.com/olekukonko/tablewriter" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -37,7 +37,7 @@ func getImagePath(image string) (string, error) { path = formatter.StripTagMeta(path) - logrus.Debugf("parsed %s from %s", path, image) + log.Debugf("parsed %s from %s", path, image) return path, nil } @@ -60,27 +60,27 @@ var appVersionCommand = cli.Command{ cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("checking whether %s is already deployed", stackName) + log.Debugf("checking whether %s is already deployed", stackName) isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isDeployed { - logrus.Fatalf("%s is not deployed?", app.Name) + log.Fatalf("%s is not deployed?", app.Name) } if deployedVersion == "unknown" { - logrus.Fatalf("failed to determine version of deployed %s", app.Name) + log.Fatalf("failed to determine version of deployed %s", app.Name) } recipeMeta, err := recipe.GetRecipeMeta(app.Recipe, internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } versionsMeta := make(map[string]recipe.ServiceMeta) @@ -91,7 +91,7 @@ var appVersionCommand = cli.Command{ } if len(versionsMeta) == 0 { - logrus.Fatalf("could not retrieve deployed version (%s) from recipe catalogue?", deployedVersion) + log.Fatalf("could not retrieve deployed version (%s) from recipe catalogue?", deployedVersion) } tableCol := []string{"version", "service", "image", "tag"} diff --git a/cli/app/volume.go b/cli/app/volume.go index 4fb72c6bd..cf21d6ab6 100644 --- a/cli/app/volume.go +++ b/cli/app/volume.go @@ -2,15 +2,14 @@ package app import ( "context" - "log" "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/upstream/stack" "github.com/AlecAivazis/survey/v2" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -30,17 +29,17 @@ var appVolumeListCommand = cli.Command{ cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } filters, err := app.Filters(false, true) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, filters) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } table := formatter.CreateTable([]string{"name", "created", "mounted"}) @@ -55,7 +54,7 @@ var appVolumeListCommand = cli.Command{ if table.NumLines() > 0 { table.Render() } else { - logrus.Warnf("no volumes created for %s", app.Name) + log.Warnf("no volumes created for %s", app.Name) } return nil @@ -90,26 +89,26 @@ Passing "--force/-f" will select all volumes for removal. Be careful. cl, err := client.New(app.Server) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } isDeployed, _, err := stack.IsDeployed(context.Background(), cl, app.StackName()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if isDeployed { - logrus.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name) + log.Fatalf("%s is still deployed. Run \"abra app undeploy %s\"", app.Name, app.Name) } filters, err := app.Filters(false, true) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } volumeList, err := client.GetVolumes(cl, context.Background(), app.Server, filters) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } volumeNames := client.GetVolumeNames(volumeList) @@ -123,7 +122,7 @@ Passing "--force/-f" will select all volumes for removal. Be careful. Default: volumeNames, } if err := survey.AskOne(volumesPrompt, &volumesToRemove); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -137,9 +136,9 @@ Passing "--force/-f" will select all volumes for removal. Be careful. log.Fatalf("removing volumes failed: %s", err) } - logrus.Infof("%d volumes removed successfully", len(volumesToRemove)) + log.Infof("%d volumes removed successfully", len(volumesToRemove)) } else { - logrus.Info("no volumes removed") + log.Info("no volumes removed") } return nil diff --git a/cli/catalogue/catalogue.go b/cli/catalogue/catalogue.go index b7d09ccca..52ee69237 100644 --- a/cli/catalogue/catalogue.go +++ b/cli/catalogue/catalogue.go @@ -12,9 +12,9 @@ import ( "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/formatter" gitPkg "coopcloud.tech/abra/pkg/git" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" "github.com/go-git/go-git/v5" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -64,13 +64,13 @@ keys configured on your account. if !internal.Chaos { if err := catalogue.EnsureIsClean(); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } repos, err := recipe.ReadReposMetadata() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } var barLength int @@ -84,9 +84,9 @@ keys configured on your account. } if !internal.SkipUpdates { - logrus.Warn(logMsg) + log.Warn(logMsg) if err := recipe.UpdateRepositories(repos, recipeName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -100,12 +100,12 @@ keys configured on your account. versions, err := recipe.GetRecipeVersions(recipeMeta.Name, internal.Offline) if err != nil { - logrus.Warn(err) + log.Warn(err) } features, category, err := recipe.GetRecipeFeaturesAndCategory(recipeMeta.Name) if err != nil { - logrus.Warn(err) + log.Warn(err) } catl[recipeMeta.Name] = recipe.RecipeMeta{ @@ -126,84 +126,84 @@ keys configured on your account. recipesJSON, err := json.MarshalIndent(catl, "", " ") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if recipeName == "" { if err := ioutil.WriteFile(config.RECIPES_JSON, recipesJSON, 0764); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { catlFS, err := recipe.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } catlFS[recipeName] = catl[recipeName] updatedRecipesJSON, err := json.MarshalIndent(catlFS, "", " ") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := ioutil.WriteFile(config.RECIPES_JSON, updatedRecipesJSON, 0764); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } - logrus.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON) + log.Infof("generated new recipe catalogue in %s", config.RECIPES_JSON) cataloguePath := path.Join(config.ABRA_DIR, "catalogue") if internal.Publish { isClean, err := gitPkg.IsClean(cataloguePath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if isClean { if !internal.Dry { - logrus.Fatalf("no changes discovered in %s, nothing to publish?", cataloguePath) + log.Fatalf("no changes discovered in %s, nothing to publish?", cataloguePath) } } msg := "chore: publish new catalogue release changes" if err := gitPkg.Commit(cataloguePath, msg, internal.Dry); err != nil { - logrus.Fatal(err) + log.Fatal(err) } repo, err := git.PlainOpen(cataloguePath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } sshURL := fmt.Sprintf(config.SSH_URL_TEMPLATE, config.CATALOGUE_JSON_REPO_NAME) if err := gitPkg.CreateRemote(repo, "origin-ssh", sshURL, internal.Dry); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := gitPkg.Push(cataloguePath, "origin-ssh", false, internal.Dry); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } repo, err := git.PlainOpen(cataloguePath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } head, err := repo.Head() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Dry && internal.Publish { url := fmt.Sprintf("%s/%s/commit/%s", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME, head.Hash()) - logrus.Infof("new changes published: %s", url) + log.Infof("new changes published: %s", url) } if internal.Dry { - logrus.Info("dry run: no changes published") + log.Info("dry run: no changes published") } return nil diff --git a/cli/cli.go b/cli/cli.go index 2bcb6ca4e..30c969d20 100644 --- a/cli/cli.go +++ b/cli/cli.go @@ -15,8 +15,8 @@ import ( "coopcloud.tech/abra/cli/server" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/config" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/web" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -53,7 +53,7 @@ Example: } if _, ok := supportedShells[shellType]; !ok { - logrus.Fatalf("%s is not a supported shell right now, sorry", shellType) + log.Fatalf("%s is not a supported shell right now, sorry", shellType) } if shellType == "fizsh" { @@ -63,17 +63,17 @@ Example: autocompletionDir := path.Join(config.ABRA_DIR, "autocompletion") if err := os.Mkdir(autocompletionDir, 0764); err != nil { if !os.IsExist(err) { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("%s already created", autocompletionDir) + log.Debugf("%s already created", autocompletionDir) } autocompletionFile := path.Join(config.ABRA_DIR, "autocompletion", shellType) if _, err := os.Stat(autocompletionFile); err != nil && os.IsNotExist(err) { url := fmt.Sprintf("https://git.coopcloud.tech/coop-cloud/abra/raw/branch/main/scripts/autocomplete/%s", shellType) - logrus.Infof("fetching %s", url) + log.Infof("fetching %s", url) if err := web.GetFile(autocompletionFile, url); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -130,10 +130,10 @@ efforts! cmd = exec.Command("bash", "-c", fmt.Sprintf("wget -q -O- %s | bash -s -- --rc", releaseCandidateURL)) } - logrus.Debugf("attempting to run %s", cmd) + log.Debugf("attempting to run %s", cmd) if err := internal.RunCmd(cmd); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -177,13 +177,13 @@ func newAbraApp(version, commit string) *cli.App { for _, path := range paths { if err := os.Mkdir(path, 0764); err != nil { if !os.IsExist(err) { - logrus.Fatal(err) + log.Fatal(err) } continue } } - logrus.Debugf("abra version %s, commit %s", version, commit) + log.Debugf("abra version %s, commit %s", version, commit) return nil } @@ -196,6 +196,6 @@ func RunApp(version, commit string) { app := newAbraApp(version, commit) if err := app.Run(os.Args); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } diff --git a/cli/internal/backup.go b/cli/internal/backup.go index 530735c99..c3a146662 100644 --- a/cli/internal/backup.go +++ b/cli/internal/backup.go @@ -5,13 +5,13 @@ import ( "coopcloud.tech/abra/pkg/config" containerPkg "coopcloud.tech/abra/pkg/container" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/service" "coopcloud.tech/abra/pkg/upstream/container" "github.com/docker/cli/cli/command" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // RetrieveBackupBotContainer gets the deployed backupbot container. @@ -22,7 +22,7 @@ func RetrieveBackupBotContainer(cl *dockerClient.Client) (types.Container, error return types.Container{}, err } - logrus.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name) + log.Debugf("retrieved %s as backup enabled service", chosenService.Spec.Name) filters := filters.NewArgs() filters.Add("name", chosenService.Spec.Name) @@ -51,7 +51,7 @@ func RunBackupCmdRemote(cl *dockerClient.Client, backupCmd string, containerID s Tty: true, } - logrus.Debugf("running backup %s on %s with exec config %v", backupCmd, containerID, execBackupListOpts) + log.Debugf("running backup %s on %s with exec config %v", backupCmd, containerID, execBackupListOpts) // FIXME: avoid instantiating a new CLI dcli, err := command.NewDockerCli() diff --git a/cli/internal/cli.go b/cli/internal/cli.go index edaa71cca..14e2acbd5 100644 --- a/cli/internal/cli.go +++ b/cli/internal/cli.go @@ -3,8 +3,7 @@ package internal import ( "os" - logrusStack "github.com/Gurpartap/logrus-stack" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" "github.com/urfave/cli" ) @@ -288,10 +287,8 @@ var AllServicesFlag = &cli.BoolFlag{ // SubCommandBefore wires up pre-action machinery (e.g. --debug handling). func SubCommandBefore(c *cli.Context) error { if Debug { - logrus.SetLevel(logrus.DebugLevel) - logrus.SetFormatter(&logrus.TextFormatter{}) - logrus.SetOutput(os.Stderr) - logrus.AddHook(logrusStack.StandardHook()) + log.SetLevel(log.DebugLevel) + log.SetOutput(os.Stderr) } return nil diff --git a/cli/internal/command.go b/cli/internal/command.go index 10f38b7b3..7a940ec9b 100644 --- a/cli/internal/command.go +++ b/cli/internal/command.go @@ -11,13 +11,13 @@ import ( appPkg "coopcloud.tech/abra/pkg/app" containerPkg "coopcloud.tech/abra/pkg/container" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/upstream/container" "github.com/docker/cli/cli/command" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" dockerClient "github.com/docker/docker/client" "github.com/docker/docker/pkg/archive" - "github.com/sirupsen/logrus" ) // RunCmdRemote executes an abra.sh command in the target service @@ -30,7 +30,7 @@ func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName, return err } - logrus.Debugf("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server) + log.Debugf("retrieved %s as target container on %s", formatter.ShortenID(targetContainer.ID), app.Server) toTarOpts := &archive.TarOptions{NoOverwriteDirNonDir: true, Compression: archive.Gzip} content, err := archive.TarWithOptions(abraSh, toTarOpts) @@ -61,7 +61,7 @@ func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName, } if _, err := container.RunExec(dcli, cl, targetContainer.ID, &execCreateOpts); err != nil { - logrus.Infof("%s does not exist for %s, use /bin/sh as fallback", shell, app.Name) + log.Infof("%s does not exist for %s, use /bin/sh as fallback", shell, app.Name) shell = "/bin/sh" } @@ -72,10 +72,10 @@ func RunCmdRemote(cl *dockerClient.Client, app appPkg.App, abraSh, serviceName, cmd = []string{shell, "-c", fmt.Sprintf("TARGET=%s; APP_NAME=%s; STACK_NAME=%s; . /tmp/abra.sh; %s", serviceName, app.Name, app.StackName(), cmdName)} } - logrus.Debugf("running command: %s", strings.Join(cmd, " ")) + log.Debugf("running command: %s", strings.Join(cmd, " ")) if RemoteUser != "" { - logrus.Debugf("running command with user %s", RemoteUser) + log.Debugf("running command with user %s", RemoteUser) execCreateOpts.User = RemoteUser } diff --git a/cli/internal/deploy.go b/cli/internal/deploy.go index 28eaacaa3..9262fd32b 100644 --- a/cli/internal/deploy.go +++ b/cli/internal/deploy.go @@ -10,9 +10,9 @@ import ( appPkg "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "github.com/AlecAivazis/survey/v2" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // NewVersionOverview shows an upgrade or downgrade overview @@ -37,7 +37,7 @@ func NewVersionOverview(app appPkg.App, currentVersion, newVersion, releaseNotes fmt.Println() fmt.Print(releaseNotes) } else { - logrus.Warnf("no release notes available for %s", newVersion) + log.Warnf("no release notes available for %s", newVersion) } if NoInput { @@ -54,7 +54,7 @@ func NewVersionOverview(app appPkg.App, currentVersion, newVersion, releaseNotes } if !response { - logrus.Fatal("exiting as requested") + log.Fatal("exiting as requested") } return nil @@ -103,7 +103,7 @@ func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error { if len(commandParts) > 2 { parsedCmdArgs = fmt.Sprintf("%s ", strings.Join(commandParts[2:], " ")) } - logrus.Infof("running post-command '%s %s' in container %s", cmdName, parsedCmdArgs, targetServiceName) + log.Infof("running post-command '%s %s' in container %s", cmdName, parsedCmdArgs, targetServiceName) if err := EnsureCommand(abraSh, app.Recipe, cmdName); err != nil { return err @@ -125,7 +125,7 @@ func PostCmds(cl *dockerClient.Client, app appPkg.App, commands string) error { return fmt.Errorf(fmt.Sprintf("no service %s for %s?", targetServiceName, app.Name)) } - logrus.Debugf("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName) + log.Debugf("running command %s %s within the context of %s_%s", cmdName, parsedCmdArgs, app.StackName(), targetServiceName) Tty = true if err := RunCmdRemote(cl, app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil { @@ -167,7 +167,7 @@ func DeployOverview(app appPkg.App, version, message string) error { } if !response { - logrus.Fatal("exiting as requested") + log.Fatal("exiting as requested") } return nil diff --git a/cli/internal/errors.go b/cli/internal/errors.go index b2885dbae..b998d092c 100644 --- a/cli/internal/errors.go +++ b/cli/internal/errors.go @@ -3,7 +3,7 @@ package internal import ( "os" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" "github.com/urfave/cli" ) @@ -11,8 +11,8 @@ import ( // terminal, and shows the help command. func ShowSubcommandHelpAndError(c *cli.Context, err interface{}) { if err2 := cli.ShowSubcommandHelp(c); err2 != nil { - logrus.Error(err2) + log.Error(err2) } - logrus.Error(err) + log.Error(err) os.Exit(1) } diff --git a/cli/internal/recipe.go b/cli/internal/recipe.go index 833255ecf..9c87cce26 100644 --- a/cli/internal/recipe.go +++ b/cli/internal/recipe.go @@ -4,10 +4,10 @@ import ( "fmt" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" "github.com/AlecAivazis/survey/v2" "github.com/distribution/reference" - "github.com/sirupsen/logrus" ) // PromptBumpType prompts for version bump type @@ -65,7 +65,7 @@ func GetBumpType() string { } else if Patch { bumpType = "patch" } else { - logrus.Fatal("no version bump type specififed?") + log.Fatal("no version bump type specififed?") } return bumpType @@ -80,7 +80,7 @@ func SetBumpType(bumpType string) { } else if bumpType == "patch" { Patch = true } else { - logrus.Fatal("no version bump type specififed?") + log.Fatal("no version bump type specififed?") } } diff --git a/cli/internal/validate.go b/cli/internal/validate.go index fa03d6987..92a0ba3a1 100644 --- a/cli/internal/validate.go +++ b/cli/internal/validate.go @@ -6,9 +6,9 @@ import ( "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/config" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" "github.com/AlecAivazis/survey/v2" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -21,7 +21,7 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe { catl, err := recipe.ReadRecipeCatalogue(Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } knownRecipes := make(map[string]bool) @@ -31,7 +31,7 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe { localRecipes, err := recipe.GetRecipesLocal() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, recipeLocal := range localRecipes { @@ -49,7 +49,7 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe { Options: recipes, } if err := survey.AskOne(prompt, &recipeName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -61,18 +61,18 @@ func ValidateRecipe(c *cli.Context) recipe.Recipe { if err != nil { if c.Command.Name == "generate" { if strings.Contains(err.Error(), "missing a compose") { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Warn(err) + log.Warn(err) } else { if strings.Contains(err.Error(), "template_driver is not allowed") { - logrus.Warnf("ensure %s recipe compose.* files include \"version: '3.8'\"", recipeName) + log.Warnf("ensure %s recipe compose.* files include \"version: '3.8'\"", recipeName) } - logrus.Fatalf("unable to validate recipe: %s", err) + log.Fatalf("unable to validate recipe: %s", err) } } - logrus.Debugf("validated %s as recipe argument", recipeName) + log.Debugf("validated %s as recipe argument", recipeName) return chosenRecipe } @@ -87,10 +87,10 @@ func ValidateApp(c *cli.Context) app.App { app, err := app.Get(appName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("validated %s as app argument", appName) + log.Debugf("validated %s as app argument", appName) return app } @@ -105,7 +105,7 @@ func ValidateDomain(c *cli.Context) string { Default: "example.com", } if err := survey.AskOne(prompt, &domainName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -113,7 +113,7 @@ func ValidateDomain(c *cli.Context) string { ShowSubcommandHelpAndError(c, errors.New("no domain provided")) } - logrus.Debugf("validated %s as domain argument", domainName) + log.Debugf("validated %s as domain argument", domainName) return domainName } @@ -138,7 +138,7 @@ func ValidateServer(c *cli.Context) string { serverNames, err := config.ReadServerNames() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if serverName == "" && !NoInput { @@ -147,7 +147,7 @@ func ValidateServer(c *cli.Context) string { Options: serverNames, } if err := survey.AskOne(prompt, &serverName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -166,7 +166,7 @@ func ValidateServer(c *cli.Context) string { ShowSubcommandHelpAndError(c, errors.New("server doesn't exist?")) } - logrus.Debugf("validated %s as server argument", serverName) + log.Debugf("validated %s as server argument", serverName) return serverName } diff --git a/cli/recipe/diff.go b/cli/recipe/diff.go index f505bbe6c..672787469 100644 --- a/cli/recipe/diff.go +++ b/cli/recipe/diff.go @@ -7,7 +7,7 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/config" gitPkg "coopcloud.tech/abra/pkg/git" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" "github.com/urfave/cli" ) @@ -32,7 +32,7 @@ var recipeDiffCommand = cli.Command{ recipeDir := path.Join(config.RECIPES_DIR, recipeName) if err := gitPkg.DiffUnstaged(recipeDir); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil diff --git a/cli/recipe/fetch.go b/cli/recipe/fetch.go index de81cfec9..4bb0cb288 100644 --- a/cli/recipe/fetch.go +++ b/cli/recipe/fetch.go @@ -4,8 +4,8 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -27,20 +27,20 @@ var recipeFetchCommand = cli.Command{ if recipeName != "" { internal.ValidateRecipe(c) if err := recipe.Ensure(recipeName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil } catalogue, err := recipe.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } catlBar := formatter.CreateProgressbar(len(catalogue), "fetching latest recipes...") for recipeName := range catalogue { if err := recipe.Ensure(recipeName); err != nil { - logrus.Error(err) + log.Error(err) } catlBar.Add(1) } diff --git a/cli/recipe/lint.go b/cli/recipe/lint.go index 542164f99..41a78db5c 100644 --- a/cli/recipe/lint.go +++ b/cli/recipe/lint.go @@ -7,8 +7,8 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/formatter" "coopcloud.tech/abra/pkg/lint" + "coopcloud.tech/abra/pkg/log" recipePkg "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -30,22 +30,22 @@ var recipeLintCommand = cli.Command{ recipe := internal.ValidateRecipe(c) if err := recipePkg.EnsureExists(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Chaos { if err := recipePkg.EnsureIsClean(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !internal.Offline { if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if err := recipePkg.EnsureLatest(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -57,7 +57,7 @@ var recipeLintCommand = cli.Command{ for level := range lint.LintRules { for _, rule := range lint.LintRules[level] { if internal.OnlyErrors && rule.Level != "error" { - logrus.Debugf("skipping %s, does not have level \"error\"", rule.Ref) + log.Debugf("skipping %s, does not have level \"error\"", rule.Ref) continue } @@ -75,7 +75,7 @@ var recipeLintCommand = cli.Command{ if !skipped { ok, err := rule.Function(recipe) if err != nil { - logrus.Warn(err) + log.Warn(err) } if !ok && rule.Level == "error" { @@ -114,7 +114,7 @@ var recipeLintCommand = cli.Command{ } if hasError { - logrus.Warn("watch out, some critical errors are present in your recipe config") + log.Warn("watch out, some critical errors are present in your recipe config") } return nil diff --git a/cli/recipe/list.go b/cli/recipe/list.go index 4ad354766..8cd136272 100644 --- a/cli/recipe/list.go +++ b/cli/recipe/list.go @@ -8,8 +8,8 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -35,7 +35,7 @@ var recipeListCommand = cli.Command{ Action: func(c *cli.Context) error { catl, err := recipe.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err.Error()) + log.Fatal(err.Error()) } recipes := catl.Flatten() diff --git a/cli/recipe/new.go b/cli/recipe/new.go index efbcc3b1d..9d6346f27 100644 --- a/cli/recipe/new.go +++ b/cli/recipe/new.go @@ -11,7 +11,7 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/git" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" "github.com/urfave/cli" ) @@ -62,19 +62,19 @@ recipe and domain in the sample environment config). directory := path.Join(config.RECIPES_DIR, recipeName) if _, err := os.Stat(directory); !os.IsNotExist(err) { - logrus.Fatalf("%s recipe directory already exists?", directory) + log.Fatalf("%s recipe directory already exists?", directory) } url := fmt.Sprintf("%s/example.git", config.REPOS_BASE_URL) if err := git.Clone(directory, url); err != nil { - logrus.Fatal(err) + log.Fatal(err) } gitRepo := path.Join(config.RECIPES_DIR, recipeName, ".git") if err := os.RemoveAll(gitRepo); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("removed example git repo in %s", gitRepo) + log.Debugf("removed example git repo in %s", gitRepo) meta := newRecipeMeta(recipeName) @@ -85,23 +85,23 @@ recipe and domain in the sample environment config). for _, path := range toParse { tpl, err := template.ParseFiles(path) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } var templated bytes.Buffer if err := tpl.Execute(&templated, meta); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := os.WriteFile(path, templated.Bytes(), 0644); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } newGitRepo := path.Join(config.RECIPES_DIR, recipeName) if err := git.Init(newGitRepo, true, internal.GitName, internal.GitEmail); err != nil { - logrus.Fatal(err) + log.Fatal(err) } fmt.Print(fmt.Sprintf(` diff --git a/cli/recipe/release.go b/cli/recipe/release.go index 50e0afa76..ad403c336 100644 --- a/cli/recipe/release.go +++ b/cli/recipe/release.go @@ -13,13 +13,13 @@ import ( "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/formatter" 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" "github.com/go-git/go-git/v5" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -65,74 +65,74 @@ your SSH keys configured on your account. imagesTmp, err := getImageVersions(recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } mainApp, err := internal.GetMainAppImage(recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } mainAppVersion := imagesTmp[mainApp] if mainAppVersion == "" { - logrus.Fatalf("main app service version for %s is empty?", recipe.Name) + log.Fatalf("main app service version for %s is empty?", recipe.Name) } tagString := c.Args().Get(1) if tagString != "" { if _, err := tagcmp.Parse(tagString); err != nil { - logrus.Fatalf("cannot parse %s, invalid tag specified?", tagString) + log.Fatalf("cannot parse %s, invalid tag specified?", tagString) } } if (internal.Major || internal.Minor || internal.Patch) && tagString != "" { - logrus.Fatal("cannot specify tag and bump type at the same time") + log.Fatal("cannot specify tag and bump type at the same time") } if tagString != "" { if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } tags, err := recipe.Tags() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if tagString == "" && (!internal.Major && !internal.Minor && !internal.Patch) { var err error tagString, err = getLabelVersion(recipe, false) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } isClean, err := gitPkg.IsClean(recipe.Dir()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isClean { - logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name) + log.Infof("%s currently has these unstaged changes 👇", recipe.Name) if err := gitPkg.DiffUnstaged(recipe.Dir()); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } if len(tags) > 0 { - logrus.Warnf("previous git tags detected, assuming this is a new semver release") + log.Warnf("previous git tags detected, assuming this is a new semver release") if err := createReleaseFromPreviousTag(tagString, mainAppVersion, recipe, tags); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { - logrus.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name) + log.Warnf("no tag specified and no previous tag available for %s, assuming this is the initial release", recipe.Name) if err := createReleaseFromTag(recipe, tagString, mainAppVersion); err != nil { if cleanUpErr := cleanUpTag(tagString, recipe.Name); err != nil { - logrus.Fatal(cleanUpErr) + log.Fatal(cleanUpErr) } - logrus.Fatal(err) + log.Fatal(err) } } @@ -210,19 +210,19 @@ func createReleaseFromTag(recipe recipe.Recipe, tagString, mainAppVersion string } if err := addReleaseNotes(recipe, tagString); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := commitRelease(recipe, tagString); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := tagRelease(tagString, repo); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := pushRelease(recipe, tagString); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -259,7 +259,7 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error { if _, err := os.Stat(nextReleaseNotePath); err == nil { // release/next note exists. Move it to release/ if internal.Dry { - logrus.Debugf("dry run: move release note from 'next' to %s", tag) + log.Debugf("dry run: move release note from 'next' to %s", tag) return nil } if !internal.NoInput { @@ -321,7 +321,7 @@ func addReleaseNotes(recipe recipe.Recipe, tag string) error { func commitRelease(recipe recipe.Recipe, tag string) error { if internal.Dry { - logrus.Debugf("dry run: no changes committed") + log.Debugf("dry run: no changes committed") return nil } @@ -347,7 +347,7 @@ func commitRelease(recipe recipe.Recipe, tag string) error { func tagRelease(tagString string, repo *git.Repository) error { if internal.Dry { - logrus.Debugf("dry run: no git tag created (%s)", tagString) + log.Debugf("dry run: no git tag created (%s)", tagString) return nil } @@ -367,14 +367,14 @@ func tagRelease(tagString string, repo *git.Repository) error { } hash := formatter.SmallSHA(head.Hash().String()) - logrus.Debugf(fmt.Sprintf("created tag %s at %s", tagString, hash)) + log.Debugf(fmt.Sprintf("created tag %s at %s", tagString, hash)) return nil } func pushRelease(recipe recipe.Recipe, tagString string) error { if internal.Dry { - logrus.Info("dry run: no changes published") + log.Info("dry run: no changes published") return nil } @@ -393,9 +393,9 @@ func pushRelease(recipe recipe.Recipe, tagString string) error { return err } url := fmt.Sprintf("%s/%s/src/tag/%s", config.REPOS_BASE_URL, recipe.Name, tagString) - logrus.Infof("new release published: %s", url) + log.Infof("new release published: %s", url) } else { - logrus.Info("no -p/--publish passed, not publishing") + log.Info("no -p/--publish passed, not publishing") } return nil @@ -468,7 +468,7 @@ func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recip } if lastGitTag.String() == tagString { - logrus.Fatalf("latest git tag (%s) and synced label (%s) are the same?", lastGitTag, tagString) + log.Fatalf("latest git tag (%s) and synced label (%s) are the same?", lastGitTag, tagString) } if !internal.NoInput { @@ -478,28 +478,28 @@ func createReleaseFromPreviousTag(tagString, mainAppVersion string, recipe recip var ok bool if err := survey.AskOne(prompt, &ok); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !ok { - logrus.Fatal("exiting as requested") + log.Fatal("exiting as requested") } } if err := addReleaseNotes(recipe, tagString); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := commitRelease(recipe, tagString); err != nil { - logrus.Fatalf("failed to commit changes: %s", err.Error()) + log.Fatalf("failed to commit changes: %s", err.Error()) } if err := tagRelease(tagString, repo); err != nil { - logrus.Fatalf("failed to tag release: %s", err.Error()) + log.Fatalf("failed to tag release: %s", err.Error()) } if err := pushRelease(recipe, tagString); err != nil { - logrus.Fatalf("failed to publish new release: %s", err.Error()) + log.Fatalf("failed to publish new release: %s", err.Error()) } return nil @@ -519,7 +519,7 @@ func cleanUpTag(tag, recipeName string) error { } } - logrus.Debugf("removed freshly created tag %s", tag) + log.Debugf("removed freshly created tag %s", tag) return nil } @@ -531,10 +531,10 @@ func getLabelVersion(recipe recipe.Recipe, prompt bool) (string, error) { } if initTag == "" { - logrus.Fatalf("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name) + log.Fatalf("unable to read version for %s from synced label. Did you try running \"abra recipe sync %s\" already?", recipe.Name, recipe.Name) } - logrus.Warnf("discovered %s as currently synced recipe label", initTag) + log.Warnf("discovered %s as currently synced recipe label", initTag) if prompt && !internal.NoInput { var response bool diff --git a/cli/recipe/reset.go b/cli/recipe/reset.go index 67208cdc1..3c4032196 100644 --- a/cli/recipe/reset.go +++ b/cli/recipe/reset.go @@ -6,8 +6,8 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/config" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -33,22 +33,22 @@ var recipeResetCommand = cli.Command{ repoPath := path.Join(config.RECIPES_DIR, recipeName) repo, err := git.PlainOpen(repoPath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } ref, err := repo.Head() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } worktree, err := repo.Worktree() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } opts := &git.ResetOptions{Commit: ref.Hash(), Mode: git.HardReset} if err := worktree.Reset(opts); err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil diff --git a/cli/recipe/sync.go b/cli/recipe/sync.go index d5b4ad006..c49b8726f 100644 --- a/cli/recipe/sync.go +++ b/cli/recipe/sync.go @@ -9,11 +9,11 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/config" gitPkg "coopcloud.tech/abra/pkg/git" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/tagcmp" "github.com/AlecAivazis/survey/v2" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/plumbing" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -47,26 +47,26 @@ local file system. mainApp, err := internal.GetMainAppImage(recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } imagesTmp, err := getImageVersions(recipe) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } mainAppVersion := imagesTmp[mainApp] tags, err := recipe.Tags() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } nextTag := c.Args().Get(1) if len(tags) == 0 && nextTag == "" { - logrus.Warnf("no git tags found for %s", recipe.Name) + log.Warnf("no git tags found for %s", recipe.Name) if internal.NoInput { - logrus.Fatalf("unable to continue, input required for initial version") + log.Fatalf("unable to continue, input required for initial version") } fmt.Println(fmt.Sprintf(` The following options are two types of initial semantic version that you can @@ -93,7 +93,7 @@ likely to change. } if err := survey.AskOne(edPrompt, &chosenVersion); err != nil { - logrus.Fatal(err) + log.Fatal(err) } nextTag = fmt.Sprintf("%s+%s", chosenVersion, mainAppVersion) @@ -102,7 +102,7 @@ likely to change. if nextTag == "" && (!internal.Major && !internal.Minor && !internal.Patch) { latestRelease := tags[len(tags)-1] if err := internal.PromptBumpType("", latestRelease); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -110,19 +110,19 @@ likely to change. recipeDir := path.Join(config.RECIPES_DIR, recipe.Name) repo, err := git.PlainOpen(recipeDir) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } var lastGitTag tagcmp.Tag iter, err := repo.Tags() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := iter.ForEach(func(ref *plumbing.Reference) error { obj, err := repo.TagObject(ref.Hash()) if err != nil { - logrus.Fatal("Tag at commit ", ref.Hash(), " is unannotated or otherwise broken. Please fix it.") + log.Fatal("Tag at commit ", ref.Hash(), " is unannotated or otherwise broken. Please fix it.") return err } @@ -139,7 +139,7 @@ likely to change. return nil }); err != nil { - logrus.Fatal(err) + log.Fatal(err) } // bumpType is used to decide what part of the tag should be incremented @@ -147,7 +147,7 @@ likely to change. if bumpType != 0 { // a bitwise check if the number is a power of 2 if (bumpType & (bumpType - 1)) != 0 { - logrus.Fatal("you can only use one version flag: --major, --minor or --patch") + log.Fatal("you can only use one version flag: --major, --minor or --patch") } } @@ -156,14 +156,14 @@ likely to change. if internal.Patch { now, err := strconv.Atoi(newTag.Patch) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } newTag.Patch = strconv.Itoa(now + 1) } else if internal.Minor { now, err := strconv.Atoi(newTag.Minor) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } newTag.Patch = "0" @@ -171,7 +171,7 @@ likely to change. } else if internal.Major { now, err := strconv.Atoi(newTag.Major) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } newTag.Patch = "0" @@ -181,32 +181,32 @@ likely to change. } newTag.Metadata = mainAppVersion - logrus.Debugf("choosing %s as new version for %s", newTag.String(), recipe.Name) + log.Debugf("choosing %s as new version for %s", newTag.String(), recipe.Name) nextTag = newTag.String() } if _, err := tagcmp.Parse(nextTag); err != nil { - logrus.Fatalf("invalid version %s specified", nextTag) + log.Fatalf("invalid version %s specified", nextTag) } mainService := "app" label := fmt.Sprintf("coop-cloud.${STACK_NAME}.version=%s", nextTag) if !internal.Dry { if err := recipe.UpdateLabel("compose.y*ml", mainService, label); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } else { - logrus.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name) + log.Infof("dry run: not syncing label %s for recipe %s", nextTag, recipe.Name) } isClean, err := gitPkg.IsClean(recipe.Dir()) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isClean { - logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name) + log.Infof("%s currently has these unstaged changes 👇", recipe.Name) if err := gitPkg.DiffUnstaged(recipe.Dir()); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } diff --git a/cli/recipe/upgrade.go b/cli/recipe/upgrade.go index 440859cc3..2daf32581 100644 --- a/cli/recipe/upgrade.go +++ b/cli/recipe/upgrade.go @@ -15,11 +15,11 @@ import ( "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/formatter" 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/distribution/reference" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -74,26 +74,26 @@ You may invoke this command in "wizard" mode and be prompted for input: recipe := internal.ValidateRecipe(c) if err := recipePkg.EnsureIsClean(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := recipePkg.EnsureExists(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := recipePkg.EnsureUpToDate(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := recipePkg.EnsureLatest(recipe.Name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } bumpType := btoi(internal.Major)*4 + btoi(internal.Minor)*2 + btoi(internal.Patch) if bumpType != 0 { // a bitwise check if the number is a power of 2 if (bumpType & (bumpType - 1)) != 0 { - logrus.Fatal("you can only use one of: --major, --minor, --patch.") + log.Fatal("you can only use one of: --major, --minor, --patch.") } } @@ -110,22 +110,22 @@ You may invoke this command in "wizard" mode and be prompted for input: versionsPath := path.Join(recipeDir, "versions") var servicePins = make(map[string]imgPin) if _, err := os.Stat(versionsPath); err == nil { - logrus.Debugf("found versions file for %s", recipe.Name) + log.Debugf("found versions file for %s", recipe.Name) file, err := os.Open(versionsPath) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } scanner := bufio.NewScanner(file) for scanner.Scan() { line := scanner.Text() splitLine := strings.Split(line, " ") if splitLine[0] != "pin" || len(splitLine) != 3 { - logrus.Fatalf("malformed version pin specification: %s", line) + log.Fatalf("malformed version pin specification: %s", line) } pinSlice := strings.Split(splitLine[2], ":") pinTag, err := tagcmp.Parse(pinSlice[1]) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } pin := imgPin{ image: pinSlice[0], @@ -134,45 +134,45 @@ You may invoke this command in "wizard" mode and be prompted for input: servicePins[splitLine[1]] = pin } if err := scanner.Err(); err != nil { - logrus.Error(err) + log.Error(err) } versionsPresent = true } else { - logrus.Debugf("did not find versions file for %s", recipe.Name) + log.Debugf("did not find versions file for %s", recipe.Name) } for _, service := range recipe.Config.Services { img, err := reference.ParseNormalizedNamed(service.Image) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } regVersions, err := client.GetRegistryTags(img) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } image := reference.Path(img) - logrus.Debugf("retrieved %s from remote registry for %s", regVersions, image) + log.Debugf("retrieved %s from remote registry for %s", regVersions, image) image = formatter.StripTagMeta(image) switch img.(type) { case reference.NamedTagged: if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) { - logrus.Debugf("%s not considered semver-like", img.(reference.NamedTagged).Tag()) + log.Debugf("%s not considered semver-like", img.(reference.NamedTagged).Tag()) } default: - logrus.Warnf("unable to read tag for image %s, is it missing? skipping upgrade for %s", image, service.Name) + log.Warnf("unable to read tag for image %s, is it missing? skipping upgrade for %s", image, service.Name) continue } tag, err := tagcmp.Parse(img.(reference.NamedTagged).Tag()) if err != nil { - logrus.Warnf("unable to parse %s, error was: %s, skipping upgrade for %s", image, err.Error(), service.Name) + log.Warnf("unable to parse %s, error was: %s, skipping upgrade for %s", image, err.Error(), service.Name) continue } - logrus.Debugf("parsed %s for %s", tag, service.Name) + log.Debugf("parsed %s for %s", tag, service.Name) var compatible []tagcmp.Tag for _, regVersion := range regVersions { @@ -186,18 +186,18 @@ You may invoke this command in "wizard" mode and be prompted for input: } } - logrus.Debugf("detected potential upgradable tags %s for %s", compatible, service.Name) + log.Debugf("detected potential upgradable tags %s for %s", compatible, service.Name) sort.Sort(tagcmp.ByTagDesc(compatible)) if len(compatible) == 0 && !internal.AllTags { - logrus.Info(fmt.Sprintf("no new versions available for %s, assuming %s is the latest (use -a/--all-tags to see all anyway)", image, tag)) + log.Info(fmt.Sprintf("no new versions available for %s, assuming %s is the latest (use -a/--all-tags to see all anyway)", image, tag)) continue // skip on to the next tag and don't update any compose files } catlVersions, err := recipePkg.VersionsOfService(recipe.Name, service.Name, internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } compatibleStrings := []string{"skip"} @@ -213,7 +213,7 @@ You may invoke this command in "wizard" mode and be prompted for input: } } - logrus.Debugf("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name) + log.Debugf("detected compatible upgradable tags %s for %s", compatibleStrings, service.Name) var upgradeTag string _, ok := servicePins[service.Name] @@ -230,13 +230,13 @@ You may invoke this command in "wizard" mode and be prompted for input: } } if contains { - logrus.Infof("upgrading service %s from %s to %s (pinned tag: %s)", service.Name, tag.String(), upgradeTag, pinnedTagString) + log.Infof("upgrading service %s from %s to %s (pinned tag: %s)", service.Name, tag.String(), upgradeTag, pinnedTagString) } else { - logrus.Infof("service %s, image %s pinned to %s, no compatible upgrade found", service.Name, servicePins[service.Name].image, pinnedTagString) + log.Infof("service %s, image %s pinned to %s, no compatible upgrade found", service.Name, servicePins[service.Name].image, pinnedTagString) continue } } else { - logrus.Fatalf("service %s is at version %s, but pinned to %s, please correct your compose.yml file manually!", service.Name, tag.String(), pinnedTag.String()) + log.Fatalf("service %s is at version %s, but pinned to %s, please correct your compose.yml file manually!", service.Name, tag.String(), pinnedTag.String()) continue } } else { @@ -253,7 +253,7 @@ You may invoke this command in "wizard" mode and be prompted for input: } } if upgradeTag == "" { - logrus.Warnf("not upgrading from %s to %s for %s, because the upgrade type is more serious than what user wants", tag.String(), compatible[0].String(), image) + log.Warnf("not upgrading from %s to %s for %s, because the upgrade type is more serious than what user wants", tag.String(), compatible[0].String(), image) continue } } else { @@ -261,7 +261,7 @@ You may invoke this command in "wizard" mode and be prompted for input: if !tagcmp.IsParsable(img.(reference.NamedTagged).Tag()) || internal.AllTags { tag := img.(reference.NamedTagged).Tag() if !internal.AllTags { - logrus.Warning(fmt.Sprintf("unable to determine versioning semantics of %s, listing all tags", tag)) + log.Warn(fmt.Sprintf("unable to determine versioning semantics of %s, listing all tags", tag)) } msg = fmt.Sprintf("upgrade to which tag? (service: %s, tag: %s)", service.Name, tag) compatibleStrings = []string{"skip"} @@ -299,7 +299,7 @@ You may invoke this command in "wizard" mode and be prompted for input: Options: compatibleStrings, } if err := survey.AskOne(prompt, &upgradeTag); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } } @@ -307,14 +307,14 @@ You may invoke this command in "wizard" mode and be prompted for input: if upgradeTag != "skip" { ok, err := recipe.UpdateTag(image, upgradeTag) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if ok { - logrus.Infof("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image) + log.Infof("tag upgraded from %s to %s for %s", tag.String(), upgradeTag, image) } } else { if !internal.NoInput { - logrus.Warnf("not upgrading %s, skipping as requested", image) + log.Warnf("not upgrading %s, skipping as requested", image) } } } @@ -323,7 +323,7 @@ You may invoke this command in "wizard" mode and be prompted for input: if internal.MachineReadable { jsonstring, err := json.Marshal(upgradeList) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } fmt.Println(string(jsonstring)) @@ -332,21 +332,21 @@ You may invoke this command in "wizard" mode and be prompted for input: } for _, upgrade := range upgradeList { - logrus.Infof("can upgrade service: %s, image: %s, tag: %s ::\n", upgrade.Service, upgrade.Image, upgrade.Tag) + log.Infof("can upgrade service: %s, image: %s, tag: %s ::\n", upgrade.Service, upgrade.Image, upgrade.Tag) for _, utag := range upgrade.UpgradeTags { - logrus.Infof(" %s\n", utag) + log.Infof(" %s\n", utag) } } } isClean, err := gitPkg.IsClean(recipeDir) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !isClean { - logrus.Infof("%s currently has these unstaged changes 👇", recipe.Name) + log.Infof("%s currently has these unstaged changes 👇", recipe.Name) if err := gitPkg.DiffUnstaged(recipeDir); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } diff --git a/cli/recipe/version.go b/cli/recipe/version.go index edad6c266..86ecc9179 100644 --- a/cli/recipe/version.go +++ b/cli/recipe/version.go @@ -7,9 +7,9 @@ import ( "coopcloud.tech/abra/cli/internal" "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" recipePkg "coopcloud.tech/abra/pkg/recipe" "github.com/olekukonko/tablewriter" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -42,16 +42,16 @@ var recipeVersionCommand = cli.Command{ catl, err := recipePkg.ReadRecipeCatalogue(internal.Offline) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } recipeMeta, ok := catl[recipe.Name] if !ok { - logrus.Fatalf("%s is not published on the catalogue?", recipe.Name) + log.Fatalf("%s is not published on the catalogue?", recipe.Name) } if len(recipeMeta.Versions) == 0 { - logrus.Fatalf("%s has no catalogue published versions?", recipe.Name) + log.Fatalf("%s has no catalogue published versions?", recipe.Name) } tableCols := []string{"version", "service", "image", "tag"} diff --git a/cli/server/add.go b/cli/server/add.go index d3e948885..4952b95c0 100644 --- a/cli/server/add.go +++ b/cli/server/add.go @@ -10,9 +10,9 @@ import ( "coopcloud.tech/abra/pkg/config" contextPkg "coopcloud.tech/abra/pkg/context" "coopcloud.tech/abra/pkg/dns" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/server" sshPkg "coopcloud.tech/abra/pkg/ssh" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -27,25 +27,25 @@ var localFlag = &cli.BoolFlag{ // "server add" attempt. func cleanUp(name string) { if name != "default" { - logrus.Debugf("serverAdd: cleanUp: cleaning up context for %s", name) + log.Debugf("serverAdd: cleanUp: cleaning up context for %s", name) if err := client.DeleteContext(name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } serverDir := filepath.Join(config.SERVERS_DIR, name) files, err := config.GetAllFilesInDirectory(serverDir) if err != nil { - logrus.Fatalf("serverAdd: cleanUp: unable to list files in %s: %s", serverDir, err) + log.Fatalf("serverAdd: cleanUp: unable to list files in %s: %s", serverDir, err) } if len(files) > 0 { - logrus.Debugf("serverAdd: cleanUp: %s is not empty, aborting cleanup", serverDir) + log.Debugf("serverAdd: cleanUp: %s is not empty, aborting cleanup", serverDir) return } if err := os.RemoveAll(serverDir); err != nil { - logrus.Fatalf("serverAdd: cleanUp: failed to remove %s: %s", serverDir, err) + log.Fatalf("serverAdd: cleanUp: failed to remove %s: %s", serverDir, err) } } @@ -62,12 +62,12 @@ func newContext(name string) (bool, error) { for _, context := range contexts { if context.Name == name { - logrus.Debugf("context for %s already exists", name) + log.Debugf("context for %s already exists", name) return false, nil } } - logrus.Debugf("creating context with domain %s", name) + log.Debugf("creating context with domain %s", name) if err := client.CreateContext(name); err != nil { return false, nil @@ -83,7 +83,7 @@ func createServerDir(name string) (bool, error) { return false, err } - logrus.Debugf("server dir for %s already created", name) + log.Debugf("server dir for %s already created", name) return false, nil } @@ -152,20 +152,20 @@ of your ~/.ssh/config. Checks for a valid online domain will be skipped: if local { created, err := createServerDir(name) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("attempting to create client for %s", name) + log.Debugf("attempting to create client for %s", name) if _, err := client.New(name, timeout); err != nil { cleanUp(name) - logrus.Fatal(err) + log.Fatal(err) } if created { - logrus.Info("local server successfully added") + log.Info("local server successfully added") } else { - logrus.Warn("local server already exists") + log.Warn("local server already exists") } return nil @@ -173,31 +173,31 @@ of your ~/.ssh/config. Checks for a valid online domain will be skipped: if !internal.NoDomainChecks { if _, err := dns.EnsureIPv4(name); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } _, err := createServerDir(name) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } created, err := newContext(name) if err != nil { cleanUp(name) - logrus.Fatal(err) + log.Fatal(err) } - logrus.Debugf("attempting to create client for %s", name) + log.Debugf("attempting to create client for %s", name) if _, err := client.New(name, timeout); err != nil { cleanUp(name) - logrus.Fatal(sshPkg.Fatal(name, err)) + log.Fatal(sshPkg.Fatal(name, err)) } if created { - logrus.Infof("%s successfully added", name) + log.Infof("%s successfully added", name) } else { - logrus.Warnf("%s already exists", name) + log.Warnf("%s already exists", name) } return nil diff --git a/cli/server/list.go b/cli/server/list.go index 6eaad343d..0596a23b9 100644 --- a/cli/server/list.go +++ b/cli/server/list.go @@ -7,8 +7,8 @@ import ( "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/context" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "github.com/docker/cli/cli/connhelper/ssh" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -35,7 +35,7 @@ var serverListCommand = cli.Command{ dockerContextStore := context.NewDefaultDockerContextStore() contexts, err := dockerContextStore.Store.List() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } tableColumns := []string{"name", "host", "user", "port"} @@ -43,7 +43,7 @@ var serverListCommand = cli.Command{ serverNames, err := config.ReadServerNames() if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, serverName := range serverNames { @@ -58,7 +58,7 @@ var serverListCommand = cli.Command{ if ctx.Name == serverName { sp, err := ssh.ParseURL(endpoint) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if sp.Host == "" { @@ -99,7 +99,7 @@ var serverListCommand = cli.Command{ table.JSONRender() } else { if problemsFilter && table.NumLines() == 0 { - logrus.Info("all servers wired up correctly 👏") + log.Info("all servers wired up correctly 👏") } else { table.Render() } diff --git a/cli/server/prune.go b/cli/server/prune.go index 8945aadfc..b670b6429 100644 --- a/cli/server/prune.go +++ b/cli/server/prune.go @@ -7,8 +7,8 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "github.com/docker/docker/api/types/filters" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -53,7 +53,7 @@ also be removed. This can result in unwanted data loss if not used carefully. cl, err := client.New(serverName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } var args filters.Args @@ -61,41 +61,41 @@ also be removed. This can result in unwanted data loss if not used carefully. ctx := context.Background() cr, err := cl.ContainersPrune(ctx, args) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed) - logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed) + log.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed) nr, err := cl.NetworksPrune(ctx, args) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted)) + log.Infof("networks pruned: %d", len(nr.NetworksDeleted)) pruneFilters := filters.NewArgs() if allFilter { - logrus.Debugf("removing all images, not only dangling ones") + log.Debugf("removing all images, not only dangling ones") pruneFilters.Add("dangling", "false") } ir, err := cl.ImagesPrune(ctx, pruneFilters) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed) - logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed) + log.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed) if volumesFilter { vr, err := cl.VolumesPrune(ctx, args) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } volSpaceReclaimed := formatter.ByteCountSI(vr.SpaceReclaimed) - logrus.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed) + log.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed) } return nil diff --git a/cli/server/remove.go b/cli/server/remove.go index d8d2ca5d7..788a09177 100644 --- a/cli/server/remove.go +++ b/cli/server/remove.go @@ -8,7 +8,7 @@ import ( "coopcloud.tech/abra/pkg/autocomplete" "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/config" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" "github.com/urfave/cli" ) @@ -34,14 +34,14 @@ rain. serverName := internal.ValidateServer(c) if err := client.DeleteContext(serverName); err != nil { - logrus.Fatal(err) + log.Fatal(err) } if err := os.RemoveAll(filepath.Join(config.SERVERS_DIR, serverName)); err != nil { - logrus.Fatal(err) + log.Fatal(err) } - logrus.Infof("%s is now lost in time, like tears in rain", serverName) + log.Infof("%s is now lost in time, like tears in rain", serverName) return nil }, diff --git a/cli/updater/updater.go b/cli/updater/updater.go index 0c39510ea..7fb7a2bd8 100644 --- a/cli/updater/updater.go +++ b/cli/updater/updater.go @@ -22,7 +22,7 @@ import ( "github.com/docker/docker/api/types/filters" dockerclient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" "github.com/urfave/cli" ) @@ -61,25 +61,25 @@ printed. To include major versions use the --major flag. Action: func(c *cli.Context) error { cl, err := client.New("default") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } stacks, err := stack.GetStacks(cl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, stackInfo := range stacks { stackName := stackInfo.Name recipeName, err := getLabel(cl, stackName, "recipe") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if recipeName != "" { _, err = getLatestUpgrade(cl, stackName, recipeName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } } @@ -114,7 +114,7 @@ update chaos deployments use the "--chaos" flag. Use it with care. Action: func(c *cli.Context) error { cl, err := client.New("default") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if !updateAll { @@ -122,7 +122,7 @@ update chaos deployments use the "--chaos" flag. Use it with care. recipeName := c.Args().Get(1) err = tryUpgrade(cl, stackName, recipeName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } return nil @@ -130,19 +130,19 @@ update chaos deployments use the "--chaos" flag. Use it with care. stacks, err := stack.GetStacks(cl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } for _, stackInfo := range stacks { stackName := stackInfo.Name recipeName, err := getLabel(cl, stackName, "recipe") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } err = tryUpgrade(cl, stackName, recipeName) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } } @@ -167,7 +167,7 @@ func getLabel(cl *dockerclient.Client, stackName string, label string) (string, } } - logrus.Debugf("no %s label found for %s", label, stackName) + log.Debugf("no %s label found for %s", label, stackName) return "", nil } @@ -188,7 +188,7 @@ func getBoolLabel(cl *dockerclient.Client, stackName string, label string) (bool return value, nil } - logrus.Debugf("Boolean label %s could not be found for %s, set default to false.", label, stackName) + log.Debugf("Boolean label %s could not be found for %s, set default to false.", label, stackName) return false, nil } @@ -209,12 +209,12 @@ func getEnv(cl *dockerclient.Client, stackName string) (envfile.AppEnv, error) { for _, envString := range envList { splitString := strings.SplitN(envString, "=", 2) if len(splitString) != 2 { - logrus.Debugf("can't separate key from value: %s (this variable is probably unset)", envString) + log.Debugf("can't separate key from value: %s (this variable is probably unset)", envString) continue } k := splitString[0] v := splitString[1] - logrus.Debugf("For %s read env %s with value: %s from docker service", stackName, k, v) + log.Debugf("For %s read env %s with value: %s from docker service", stackName, k, v) envMap[k] = v } } @@ -236,14 +236,14 @@ func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName stri } if len(availableUpgrades) == 0 { - logrus.Debugf("no available upgrades for %s", stackName) + log.Debugf("no available upgrades for %s", stackName) return "", nil } var chosenUpgrade string if len(availableUpgrades) > 0 { chosenUpgrade = availableUpgrades[len(availableUpgrades)-1] - logrus.Infof("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade) + log.Infof("%s (%s) can be upgraded from version %s to %s", stackName, recipeName, deployedVersion, chosenUpgrade) } return chosenUpgrade, nil @@ -251,7 +251,7 @@ func getLatestUpgrade(cl *dockerclient.Client, stackName string, recipeName stri // getDeployedVersion returns the currently deployed version of an app. func getDeployedVersion(cl *dockerclient.Client, stackName string, recipeName string) (string, error) { - logrus.Debugf("Retrieve deployed version whether %s is already deployed", stackName) + log.Debugf("Retrieve deployed version whether %s is already deployed", stackName) isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName) if err != nil { @@ -285,7 +285,7 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName } if len(versions) == 0 { - logrus.Warnf("no published releases for %s in the recipe catalogue?", recipeName) + log.Warnf("no published releases for %s in the recipe catalogue?", recipeName) return nil, nil } @@ -311,7 +311,7 @@ func getAvailableUpgrades(cl *dockerclient.Client, stackName string, recipeName } } - logrus.Debugf("Available updates for %s: %s", stackName, availableUpgrades) + log.Debugf("Available updates for %s: %s", stackName, availableUpgrades) return availableUpgrades, nil } @@ -349,7 +349,7 @@ func mergeAbraShEnv(recipeName string, env envfile.AppEnv) error { } for k, v := range abraShEnv { - logrus.Debugf("read v:%s k: %s", v, k) + log.Debugf("read v:%s k: %s", v, k) env[k] = v } @@ -391,7 +391,7 @@ func createDeployConfig(recipeName string, stackName string, env envfile.AppEnv) // tryUpgrade performs the upgrade if all the requirements are fulfilled. func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error { if recipeName == "" { - logrus.Debugf("don't update %s due to missing recipe name", stackName) + log.Debugf("don't update %s due to missing recipe name", stackName) return nil } @@ -401,7 +401,7 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error { } if chaos && !internal.Chaos { - logrus.Debugf("don't update %s due to chaos deployment", stackName) + log.Debugf("don't update %s due to chaos deployment", stackName) return nil } @@ -411,7 +411,7 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error { } if !updatesEnabled { - logrus.Debugf("don't update %s due to disabled auto updates or missing ENABLE_AUTO_UPDATE env", stackName) + log.Debugf("don't update %s due to disabled auto updates or missing ENABLE_AUTO_UPDATE env", stackName) return nil } @@ -421,7 +421,7 @@ func tryUpgrade(cl *dockerclient.Client, stackName, recipeName string) error { } if upgradeVersion == "" { - logrus.Debugf("don't update %s due to no new version", stackName) + log.Debugf("don't update %s due to no new version", stackName) return nil } @@ -458,7 +458,7 @@ func upgrade(cl *dockerclient.Client, stackName, recipeName, return err } - logrus.Infof("upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion) + log.Infof("upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion) err = stack.RunDeploy(cl, deployOpts, compose, stackName, true) @@ -484,7 +484,7 @@ func newAbraApp(version, commit string) *cli.App { } app.Before = func(c *cli.Context) error { - logrus.Debugf("kadabra version %s, commit %s", version, commit) + log.Debugf("kadabra version %s, commit %s", version, commit) return nil } @@ -496,6 +496,6 @@ func RunApp(version, commit string) { app := newAbraApp(version, commit) if err := app.Run(os.Args); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } diff --git a/go.mod b/go.mod index a7e1c3a12..a3d7a4ba8 100644 --- a/go.mod +++ b/go.mod @@ -6,7 +6,7 @@ require ( coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb git.coopcloud.tech/coop-cloud/godotenv v1.5.2-0.20231130100509-01bff8284355 github.com/AlecAivazis/survey/v2 v2.3.7 - github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4 + github.com/charmbracelet/log v0.4.0 github.com/distribution/reference v0.6.0 github.com/docker/cli v26.1.4+incompatible github.com/docker/docker v26.1.4+incompatible @@ -18,7 +18,7 @@ require ( github.com/olekukonko/tablewriter v0.0.5 github.com/pkg/errors v0.9.1 github.com/schollz/progressbar/v3 v3.14.4 - github.com/sirupsen/logrus v1.9.3 + gopkg.in/yaml.v3 v3.0.1 gotest.tools/v3 v3.5.1 ) @@ -28,9 +28,11 @@ require ( github.com/BurntSushi/toml v1.4.0 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect github.com/ProtonMail/go-crypto v1.0.0 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v4 v4.3.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/charmbracelet/lipgloss v0.10.0 // indirect github.com/cloudflare/circl v1.3.9 // indirect github.com/containerd/log v0.1.0 // indirect github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect @@ -46,6 +48,7 @@ require ( github.com/ghodss/yaml v1.0.0 // indirect github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect github.com/go-git/go-billy/v5 v5.5.0 // indirect + github.com/go-logfmt/logfmt v0.6.0 // indirect github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/gogo/protobuf v1.3.2 // indirect @@ -57,6 +60,7 @@ require ( github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect github.com/kevinburke/ssh_config v1.2.0 // indirect github.com/klauspost/compress v1.17.9 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/mattn/go-runewidth v0.0.15 // indirect @@ -67,6 +71,8 @@ require ( github.com/moby/docker-image-spec v1.3.1 // indirect github.com/moby/sys/user v0.1.0 // indirect github.com/morikuni/aec v1.0.0 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/muesli/termenv v0.15.2 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/runc v1.1.13 // indirect github.com/pjbgf/sha1cd v0.3.0 // indirect @@ -76,6 +82,7 @@ require ( github.com/prometheus/procfs v0.15.1 // indirect github.com/rivo/uniseg v0.4.7 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/sirupsen/logrus v1.9.3 // indirect github.com/skeema/knownhosts v1.2.2 // indirect github.com/spf13/pflag v1.0.5 // indirect github.com/xanzy/ssh-agent v0.3.3 // indirect @@ -92,6 +99,7 @@ require ( go.opentelemetry.io/otel/trace v1.27.0 // indirect go.opentelemetry.io/proto/otlp v1.3.1 // indirect golang.org/x/crypto v0.24.0 // indirect + golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect golang.org/x/net v0.26.0 // indirect golang.org/x/sync v0.7.0 // indirect golang.org/x/term v0.21.0 // indirect @@ -103,7 +111,6 @@ require ( google.golang.org/protobuf v1.34.2 // indirect gopkg.in/warnings.v0 v0.1.2 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) require ( @@ -113,7 +120,6 @@ require ( github.com/containers/storage v1.38.2 // indirect github.com/decentral1se/passgen v1.0.1 github.com/docker/docker-credential-helpers v0.8.2 // indirect - github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 // indirect github.com/fvbommel/sortorder v1.1.0 // indirect github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect github.com/gorilla/mux v1.8.1 // indirect diff --git a/go.sum b/go.sum index fff7c0bf3..95d62fab8 100644 --- a/go.sum +++ b/go.sum @@ -53,8 +53,6 @@ github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbi github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0= github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4 h1:vdT7QwBhJJEVNFMBNhRSFDRCB6O16T28VhvqRgqFyn8= -github.com/Gurpartap/logrus-stack v0.0.0-20170710170904-89c00d8a28f4/go.mod h1:SvXOG8ElV28oAiG9zv91SDe5+9PfIr7PPccpr8YyXNs= github.com/Microsoft/go-winio v0.4.11/go.mod h1:VhR8bwka0BXejwEJY73c50VrPtXAaKcyvVC4A4RozmA= github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA= github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw= @@ -106,6 +104,8 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= github.com/aws/aws-sdk-go v1.15.11/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= github.com/beorn7/perks v0.0.0-20150223135152-b965b613227f/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= @@ -139,6 +139,10 @@ github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghf github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/charmbracelet/lipgloss v0.10.0 h1:KWeXFSexGcfahHX+54URiZGkBFazf70JNMtwg/AFW3s= +github.com/charmbracelet/lipgloss v0.10.0/go.mod h1:Wig9DSfvANsxqkRsqj6x87irdy123SR4dOXlKa91ciE= +github.com/charmbracelet/log v0.4.0 h1:G9bQAcx8rWA2T3pWvx7YtPTPwgqpk7D68BX21IRW8ZM= +github.com/charmbracelet/log v0.4.0/go.mod h1:63bXt/djrizTec0l11H20t8FDSvA4CRZJ1KH22MdptM= github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw= github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M= github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E= @@ -349,8 +353,6 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.m github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0= github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= -github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 h1:JWuenKqqX8nojtoVVWjGfOF9635RETekkoH6Cc9SX0A= -github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= @@ -387,6 +389,8 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4= +github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= @@ -594,6 +598,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/lib/pq v0.0.0-20150723085316-0dad96c0b94f/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/linuxkit/virtsock v0.0.0-20201010232012-f8cee7dfc7a3/go.mod h1:3r6x7q95whyfWQpmGZTu3gk3v2YkMi05HEzl7Tf7YEo= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/magiconair/properties v1.5.3/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= @@ -613,6 +619,7 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/mattn/go-shellwords v1.0.3/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o= @@ -666,6 +673,10 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo= +github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8= github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= @@ -782,6 +793,7 @@ github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= @@ -982,6 +994,8 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI= +golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= diff --git a/pkg/app/app.go b/pkg/app/app.go index 6cb657c99..3c2ee619f 100644 --- a/pkg/app/app.go +++ b/pkg/app/app.go @@ -17,11 +17,11 @@ import ( "coopcloud.tech/abra/pkg/upstream/convert" "coopcloud.tech/abra/pkg/upstream/stack" + "coopcloud.tech/abra/pkg/log" loader "coopcloud.tech/abra/pkg/upstream/stack" composetypes "github.com/docker/cli/cli/compose/types" "github.com/docker/docker/api/types/filters" "github.com/schollz/progressbar/v3" - "github.com/sirupsen/logrus" ) // Get retrieves an app @@ -36,7 +36,7 @@ func Get(appName string) (App, error) { return App{}, err } - logrus.Debugf("retrieved %s for %s", app, appName) + log.Debugf("retrieved %s for %s", app, appName) return app, nil } @@ -125,7 +125,7 @@ func StackName(appName string) string { stackName := SanitiseAppName(appName) if len(stackName) > config.MAX_SANITISED_APP_NAME_LENGTH { - logrus.Debugf("trimming %s to %s to avoid runtime limits", stackName, stackName[:config.MAX_SANITISED_APP_NAME_LENGTH]) + log.Debugf("trimming %s to %s to avoid runtime limits", stackName, stackName[:config.MAX_SANITISED_APP_NAME_LENGTH]) stackName = stackName[:config.MAX_SANITISED_APP_NAME_LENGTH] } @@ -235,7 +235,7 @@ func ReadAppEnvFile(appFile AppFile, name AppName) (App, error) { 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) + log.Debugf("read env %s from %s", env, appFile.Path) app, err := NewApp(env, name, appFile) if err != nil { @@ -281,7 +281,7 @@ func LoadAppFiles(servers ...string) (AppFiles, error) { } } - logrus.Debugf("collecting metadata from %v servers: %s", len(servers), strings.Join(servers, ", ")) + log.Debugf("collecting metadata from %v servers: %s", len(servers), strings.Join(servers, ", ")) for _, server := range servers { serverDir := path.Join(config.SERVERS_DIR, server) @@ -387,7 +387,7 @@ func TemplateAppEnvSample(recipeName, appName, server, domain string) error { return err } - logrus.Debugf("copied & templated %s to %s", envSamplePath, appEnvPath) + log.Debugf("copied & templated %s to %s", envSamplePath, appEnvPath) return nil } @@ -472,7 +472,7 @@ func GetAppStatuses(apps []App, MachineReadable bool) (map[string]map[string]str } } - logrus.Debugf("retrieved app statuses: %s", statuses) + log.Debugf("retrieved app statuses: %s", statuses) return statuses, nil } @@ -486,7 +486,7 @@ func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv envfile.AppEnv return &composetypes.Config{}, err } - logrus.Debugf("retrieved %s for %s", compose.Filename, recipe) + log.Debugf("retrieved %s for %s", compose.Filename, recipe) return compose, nil } @@ -495,13 +495,13 @@ func GetAppComposeConfig(recipe string, opts stack.Deploy, appEnv envfile.AppEnv func ExposeAllEnv(stackName string, compose *composetypes.Config, appEnv envfile.AppEnv) { for _, service := range compose.Services { if service.Name == "app" { - logrus.Debugf("Add the following environment to the app service config of %s:", stackName) + log.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) + log.Debugf("Add Key: %s Value: %s to %s", k, value, stackName) } } } @@ -570,9 +570,9 @@ func ReadAbraShCmdNames(abraSh string) ([]string, error) { } if len(cmdNames) > 0 { - logrus.Debugf("read %s from %s", strings.Join(cmdNames, " "), abraSh) + log.Debugf("read %s from %s", strings.Join(cmdNames, " "), abraSh) } else { - logrus.Debugf("read 0 command names from %s", abraSh) + log.Debugf("read 0 command names from %s", abraSh) } return cmdNames, nil diff --git a/pkg/app/compose.go b/pkg/app/compose.go index f3109fdda..4d9573b8e 100644 --- a/pkg/app/compose.go +++ b/pkg/app/compose.go @@ -5,8 +5,8 @@ import ( "strconv" "coopcloud.tech/abra/pkg/envfile" + "coopcloud.tech/abra/pkg/log" composetypes "github.com/docker/cli/cli/compose/types" - "github.com/sirupsen/logrus" ) // SetRecipeLabel adds the label 'coop-cloud.${STACK_NAME}.recipe=${RECIPE}' to the app container @@ -14,7 +14,7 @@ import ( 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) + log.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 } @@ -26,7 +26,7 @@ func SetRecipeLabel(compose *composetypes.Config, stackName string, recipe strin func SetChaosLabel(compose *composetypes.Config, stackName string, chaos bool) { for _, service := range compose.Services { if service.Name == "app" { - logrus.Debugf("set label 'coop-cloud.%s.chaos' to %v for %s", stackName, chaos, stackName) + log.Debugf("set label 'coop-cloud.%s.chaos' to %v for %s", stackName, chaos, stackName) labelKey := fmt.Sprintf("coop-cloud.%s.chaos", stackName) service.Deploy.Labels[labelKey] = strconv.FormatBool(chaos) } @@ -37,7 +37,7 @@ func SetChaosLabel(compose *composetypes.Config, stackName string, chaos bool) { func SetChaosVersionLabel(compose *composetypes.Config, stackName string, chaosVersion string) { for _, service := range compose.Services { if service.Name == "app" { - logrus.Debugf("set label 'coop-cloud.%s.chaos-version' to %v for %s", stackName, chaosVersion, stackName) + log.Debugf("set label 'coop-cloud.%s.chaos-version' to %v for %s", stackName, chaosVersion, stackName) labelKey := fmt.Sprintf("coop-cloud.%s.chaos-version", stackName) service.Deploy.Labels[labelKey] = chaosVersion } @@ -54,7 +54,7 @@ func SetUpdateLabel(compose *composetypes.Config, stackName string, appEnv envfi if !exists { enable_auto_update = "false" } - logrus.Debugf("set label 'coop-cloud.%s.autoupdate' to %s for %s", stackName, enable_auto_update, stackName) + log.Debugf("set label 'coop-cloud.%s.autoupdate' to %s for %s", stackName, enable_auto_update, stackName) labelKey := fmt.Sprintf("coop-cloud.%s.autoupdate", stackName) service.Deploy.Labels[labelKey] = enable_auto_update } @@ -66,13 +66,13 @@ func GetLabel(compose *composetypes.Config, stackName string, label string) stri for _, service := range compose.Services { if service.Name == "app" { labelKey := fmt.Sprintf("coop-cloud.%s.%s", stackName, label) - logrus.Debugf("get label '%s'", labelKey) + log.Debugf("get label '%s'", labelKey) if labelValue, ok := service.Deploy.Labels[labelKey]; ok { return labelValue } } } - logrus.Debugf("no %s label found for %s", label, stackName) + log.Debugf("no %s label found for %s", label, stackName) return "" } @@ -81,7 +81,7 @@ func GetTimeoutFromLabel(compose *composetypes.Config, stackName string) (int, e timeout := 50 // Default Timeout var err error = nil if timeoutLabel := GetLabel(compose, stackName, "timeout"); timeoutLabel != "" { - logrus.Debugf("timeout label: %s", timeoutLabel) + log.Debugf("timeout label: %s", timeoutLabel) timeout, err = strconv.Atoi(timeoutLabel) } return timeout, err diff --git a/pkg/autocomplete/autocomplete.go b/pkg/autocomplete/autocomplete.go index 5a499e2ba..f34eca30c 100644 --- a/pkg/autocomplete/autocomplete.go +++ b/pkg/autocomplete/autocomplete.go @@ -4,8 +4,8 @@ import ( "fmt" "coopcloud.tech/abra/pkg/app" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" - "github.com/sirupsen/logrus" "github.com/urfave/cli" ) @@ -13,7 +13,7 @@ import ( func AppNameComplete(c *cli.Context) { appNames, err := app.GetAppNames() if err != nil { - logrus.Warn(err) + log.Warn(err) } if c.NArg() > 0 { @@ -39,7 +39,7 @@ func ServiceNameComplete(appName string) { func RecipeNameComplete(c *cli.Context) { catl, err := recipe.ReadRecipeCatalogue(false) if err != nil { - logrus.Warn(err) + log.Warn(err) } if c.NArg() > 0 { @@ -55,7 +55,7 @@ func RecipeNameComplete(c *cli.Context) { func RecipeVersionComplete(recipeName string) { catl, err := recipe.ReadRecipeCatalogue(false) if err != nil { - logrus.Warn(err) + log.Warn(err) } for _, v := range catl[recipeName].Versions { @@ -69,7 +69,7 @@ func RecipeVersionComplete(recipeName string) { func ServerNameComplete(c *cli.Context) { files, err := app.LoadAppFiles("") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if c.NArg() > 0 { diff --git a/pkg/catalogue/catalogue.go b/pkg/catalogue/catalogue.go index 80e548851..e3fabb378 100644 --- a/pkg/catalogue/catalogue.go +++ b/pkg/catalogue/catalogue.go @@ -8,21 +8,21 @@ import ( "coopcloud.tech/abra/pkg/config" gitPkg "coopcloud.tech/abra/pkg/git" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" - "github.com/sirupsen/logrus" ) // EnsureCatalogue ensures that the catalogue is cloned locally & present. func EnsureCatalogue() error { catalogueDir := path.Join(config.ABRA_DIR, "catalogue") if _, err := os.Stat(catalogueDir); err != nil && os.IsNotExist(err) { - logrus.Warnf("local recipe catalogue is missing, retrieving now") + log.Warnf("local recipe catalogue is missing, retrieving now") url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME) if err := gitPkg.Clone(catalogueDir, url); err != nil { return err } - logrus.Debugf("cloned catalogue repository to %s", catalogueDir) + log.Debugf("cloned catalogue repository to %s", catalogueDir) } return nil @@ -57,7 +57,7 @@ func EnsureUpToDate() error { if len(remotes) == 0 { msg := "cannot ensure %s is up-to-date, no git remotes configured" - logrus.Debugf(msg, config.CATALOGUE_DIR) + log.Debugf(msg, config.CATALOGUE_DIR) return nil } @@ -82,7 +82,7 @@ func EnsureUpToDate() error { } } - logrus.Debugf("fetched latest git changes for %s", config.CATALOGUE_DIR) + log.Debugf("fetched latest git changes for %s", config.CATALOGUE_DIR) return nil } diff --git a/pkg/client/client.go b/pkg/client/client.go index e11c48062..315a27322 100644 --- a/pkg/client/client.go +++ b/pkg/client/client.go @@ -10,10 +10,10 @@ import ( "time" contextPkg "coopcloud.tech/abra/pkg/context" + "coopcloud.tech/abra/pkg/log" sshPkg "coopcloud.tech/abra/pkg/ssh" commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn" "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // Conf is a Docker client configuration. @@ -85,7 +85,7 @@ func New(serverName string, opts ...Opt) (*client.Client, error) { return nil, err } - logrus.Debugf("created client for %s", serverName) + log.Debugf("created client for %s", serverName) info, err := cl.Info(context.Background()) if err != nil { diff --git a/pkg/client/context.go b/pkg/client/context.go index 66f5e43c4..4408bda54 100644 --- a/pkg/client/context.go +++ b/pkg/client/context.go @@ -5,11 +5,11 @@ import ( "fmt" "coopcloud.tech/abra/pkg/context" + "coopcloud.tech/abra/pkg/log" commandconnPkg "coopcloud.tech/abra/pkg/upstream/commandconn" dConfig "github.com/docker/cli/cli/config" "github.com/docker/cli/cli/context/docker" contextStore "github.com/docker/cli/cli/context/store" - "github.com/sirupsen/logrus" ) type Context = contextStore.Metadata @@ -22,7 +22,7 @@ func CreateContext(contextName string) error { return err } - logrus.Debugf("created the %s context", contextName) + log.Debugf("created the %s context", contextName) return nil } diff --git a/pkg/client/volumes.go b/pkg/client/volumes.go index f295b081c..c7af7619f 100644 --- a/pkg/client/volumes.go +++ b/pkg/client/volumes.go @@ -5,10 +5,10 @@ import ( "fmt" "time" + "coopcloud.tech/abra/pkg/log" "github.com/docker/docker/api/types/filters" "github.com/docker/docker/api/types/volume" "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) func GetVolumes(cl *client.Client, ctx context.Context, server string, fs filters.Args) ([]*volume.Volume, error) { @@ -54,7 +54,7 @@ func retryFunc(retries int, fn func() error) error { } if i+1 < retries { sleep := time.Duration(i+1) * time.Duration(i+1) - logrus.Infof("%s: waiting %d seconds before next retry", err, sleep) + log.Infof("%s: waiting %d seconds before next retry", err, sleep) time.Sleep(sleep * time.Second) } } diff --git a/pkg/compose/compose.go b/pkg/compose/compose.go index 6d116a978..db7a77461 100644 --- a/pkg/compose/compose.go +++ b/pkg/compose/compose.go @@ -10,11 +10,11 @@ import ( "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/envfile" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/upstream/stack" loader "coopcloud.tech/abra/pkg/upstream/stack" "github.com/distribution/reference" composetypes "github.com/docker/cli/cli/compose/types" - "github.com/sirupsen/logrus" ) // UpdateTag updates an image tag in-place on file system local compose files. @@ -24,7 +24,7 @@ func UpdateTag(pattern, image, tag, recipeName string) (bool, error) { return false, err } - logrus.Debugf("considering %s config(s) for tag update", strings.Join(composeFiles, ", ")) + log.Debugf("considering %s config(s) for tag update", strings.Join(composeFiles, ", ")) for _, composeFile := range composeFiles { opts := stack.Deploy{Composefiles: []string{composeFile}} @@ -55,13 +55,13 @@ func UpdateTag(pattern, image, tag, recipeName string) (bool, error) { case reference.NamedTagged: composeTag = img.(reference.NamedTagged).Tag() default: - logrus.Debugf("unable to parse %s, skipping", img) + log.Debugf("unable to parse %s, skipping", img) continue } composeImage := formatter.StripTagMeta(reference.Path(img)) - logrus.Debugf("parsed %s from %s", composeTag, service.Image) + log.Debugf("parsed %s from %s", composeTag, service.Image) if image == composeImage { bytes, err := ioutil.ReadFile(composeFile) @@ -73,7 +73,7 @@ func UpdateTag(pattern, image, tag, recipeName string) (bool, error) { new := fmt.Sprintf("%s:%s", composeImage, tag) replacedBytes := strings.Replace(string(bytes), old, new, -1) - logrus.Debugf("updating %s to %s in %s", old, new, compose.Filename) + log.Debugf("updating %s to %s in %s", old, new, compose.Filename) if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0764); err != nil { return false, err @@ -92,7 +92,7 @@ func UpdateLabel(pattern, serviceName, label, recipeName string) error { return err } - logrus.Debugf("considering %s config(s) for label update", strings.Join(composeFiles, ", ")) + log.Debugf("considering %s config(s) for label update", strings.Join(composeFiles, ", ")) for _, composeFile := range composeFiles { opts := stack.Deploy{Composefiles: []string{composeFile}} @@ -135,23 +135,23 @@ func UpdateLabel(pattern, serviceName, label, recipeName string) error { replacedBytes := strings.Replace(string(bytes), old, label, -1) if old == label { - logrus.Warnf("%s is already set, nothing to do?", label) + log.Warnf("%s is already set, nothing to do?", label) return nil } - logrus.Debugf("updating %s to %s in %s", old, label, compose.Filename) + log.Debugf("updating %s to %s in %s", old, label, compose.Filename) if err := ioutil.WriteFile(compose.Filename, []byte(replacedBytes), 0764); err != nil { return err } - logrus.Infof("synced label %s to service %s", label, serviceName) + log.Infof("synced label %s to service %s", label, serviceName) } } if !discovered { - logrus.Warn("no existing label found, automagic insertion not supported yet") - logrus.Fatalf("add '- \"%s\"' manually to the 'app' service in %s", label, composeFile) + log.Warn("no existing label found, automagic insertion not supported yet") + log.Fatalf("add '- \"%s\"' manually to the 'app' service in %s", label, composeFile) } } diff --git a/pkg/config/abra.go b/pkg/config/abra.go index ecd799af3..0b13b04dd 100644 --- a/pkg/config/abra.go +++ b/pkg/config/abra.go @@ -5,7 +5,7 @@ import ( "path" "path/filepath" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" "gopkg.in/yaml.v3" ) @@ -16,13 +16,13 @@ func LoadAbraConfig() Abra { wd, _ := os.Getwd() configFile := findAbraConfig(wd) if configFile == "" { - logrus.Debugf("no config file found") + log.Debugf("no config file found") return Abra{} } data, err := os.ReadFile(configFile) if err != nil { // Do nothing, when an error occurs - logrus.Debugf("error reading config file: %s", err) + log.Debugf("error reading config file: %s", err) return Abra{} } @@ -30,10 +30,10 @@ func LoadAbraConfig() Abra { err = yaml.Unmarshal(data, &config) if err != nil { // Do nothing, when an error occurs - logrus.Debugf("error loading config file: %s", err) + log.Debugf("error loading config file: %s", err) return Abra{} } - logrus.Debugf("config file loaded from: %s", configFile) + log.Debugf("config file loaded from: %s", configFile) config.configPath = configFile return config } @@ -73,18 +73,18 @@ type Abra struct { // 3. use $HOME/.abra when above two options failed func (a Abra) GetAbraDir() string { if dir, exists := os.LookupEnv("ABRA_DIR"); exists && dir != "" { - logrus.Debug("read abra dir from $ABRA_DIR") + log.Debug("read abra dir from $ABRA_DIR") return dir } if a.AbraDir != "" { - logrus.Debug("read abra dir from config file") + log.Debug("read abra dir from config file") if path.IsAbs(a.AbraDir) { return a.AbraDir } // Make the path absolute return path.Join(a.configPath, a.AbraDir) } - logrus.Debug("using default abra dir") + log.Debug("using default abra dir") return os.ExpandEnv("$HOME/.abra") } diff --git a/pkg/config/env.go b/pkg/config/env.go index e9c080b85..68a1d1c10 100644 --- a/pkg/config/env.go +++ b/pkg/config/env.go @@ -9,7 +9,7 @@ import ( "path/filepath" "strings" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" ) const MAX_SANITISED_APP_NAME_LENGTH = 45 @@ -26,7 +26,7 @@ func GetServers() ([]string, error) { return servers, err } - logrus.Debugf("retrieved %v servers: %s", len(servers), servers) + log.Debugf("retrieved %v servers: %s", len(servers), servers) return servers, nil } @@ -39,7 +39,7 @@ func ReadServerNames() ([]string, error) { return nil, err } - logrus.Debugf("read %s from %s", strings.Join(serverNames, ","), SERVERS_DIR) + log.Debugf("read %s from %s", strings.Join(serverNames, ","), SERVERS_DIR) return serverNames, nil } @@ -63,7 +63,7 @@ func GetAllFilesInDirectory(directory string) ([]fs.FileInfo, error) { realPath, err := filepath.EvalSymlinks(filePath) if err != nil { - logrus.Warningf("broken symlink in your abra config folders: %s", filePath) + log.Warnf("broken symlink in your abra config folders: %s", filePath) } else { realFile, err := os.Stat(realPath) if err != nil { @@ -96,7 +96,7 @@ func GetAllFoldersInDirectory(directory string) ([]string, error) { filePath := path.Join(directory, file.Name()) realDir, err := filepath.EvalSymlinks(filePath) if err != nil { - logrus.Warningf("broken symlink in your abra config folders: %s", filePath) + log.Warnf("broken symlink in your abra config folders: %s", filePath) } else if stat, err := os.Stat(realDir); err == nil && stat.IsDir() { // path is a directory folders = append(folders, file.Name()) diff --git a/pkg/container/container.go b/pkg/container/container.go index 2717e4e65..163162184 100644 --- a/pkg/container/container.go +++ b/pkg/container/container.go @@ -6,12 +6,12 @@ import ( "strings" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "github.com/AlecAivazis/survey/v2" "github.com/docker/docker/api/types" containerTypes "github.com/docker/docker/api/types/container" "github.com/docker/docker/api/types/filters" "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // GetContainer retrieves a container. If noInput is false and the retrievd @@ -43,7 +43,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no return types.Container{}, err } - logrus.Warnf("ambiguous container list received, prompting for input") + log.Warnf("ambiguous container list received, prompting for input") var response string prompt := &survey.Select{ @@ -64,7 +64,7 @@ func GetContainer(c context.Context, cl *client.Client, filters filters.Args, no } } - logrus.Panic("failed to match chosen container") + log.Fatal("failed to match chosen container") } return containers[0], nil diff --git a/pkg/envfile/envfile.go b/pkg/envfile/envfile.go index 2692b2f28..3a9df1ca9 100644 --- a/pkg/envfile/envfile.go +++ b/pkg/envfile/envfile.go @@ -7,8 +7,8 @@ import ( "regexp" "strings" + "coopcloud.tech/abra/pkg/log" "git.coopcloud.tech/coop-cloud/godotenv" - "github.com/sirupsen/logrus" ) // envVarModifiers is a list of env var modifier strings. These are added to @@ -31,7 +31,7 @@ func ReadEnv(filePath string) (AppEnv, error) { return nil, err } - logrus.Debugf("read %s from %s", envVars, filePath) + log.Debugf("read %s from %s", envVars, filePath) return envVars, nil } @@ -45,7 +45,7 @@ func ReadEnvWithModifiers(filePath string) (AppEnv, AppModifiers, error) { return nil, mods, err } - logrus.Debugf("read %s from %s", envVars, filePath) + log.Debugf("read %s from %s", envVars, filePath) return envVars, mods, nil } @@ -83,9 +83,9 @@ func ReadAbraShEnvVars(abraSh string) (map[string]string, error) { } if len(envVars) > 0 { - logrus.Debugf("read %s from %s", envVars, abraSh) + log.Debugf("read %s from %s", envVars, abraSh) } else { - logrus.Debugf("read 0 env var exports from %s", abraSh) + log.Debugf("read 0 env var exports from %s", abraSh) } return envVars, nil diff --git a/pkg/formatter/formatter.go b/pkg/formatter/formatter.go index f733127d0..1983bade1 100644 --- a/pkg/formatter/formatter.go +++ b/pkg/formatter/formatter.go @@ -9,8 +9,8 @@ import ( "github.com/docker/go-units" // "github.com/olekukonko/tablewriter" "coopcloud.tech/abra/pkg/jsontable" + "coopcloud.tech/abra/pkg/log" "github.com/schollz/progressbar/v3" - "github.com/sirupsen/logrus" ) func ShortenID(str string) string { @@ -66,7 +66,7 @@ func StripTagMeta(image string) string { } if originalImage != image { - logrus.Debugf("stripped %s to %s for parsing", originalImage, image) + log.Debugf("stripped %s to %s for parsing", originalImage, image) } return image diff --git a/pkg/git/add.go b/pkg/git/add.go index 36668568a..d5bc3d14e 100644 --- a/pkg/git/add.go +++ b/pkg/git/add.go @@ -1,8 +1,8 @@ package git import ( + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" - "github.com/sirupsen/logrus" ) // Add adds a file to the git index. @@ -18,7 +18,7 @@ func Add(repoPath, path string, dryRun bool) error { } if dryRun { - logrus.Debugf("dry run: adding %s", path) + log.Debugf("dry run: adding %s", path) } else { worktree.Add(path) } diff --git a/pkg/git/branch.go b/pkg/git/branch.go index 11de4f42d..1125bd3aa 100644 --- a/pkg/git/branch.go +++ b/pkg/git/branch.go @@ -3,9 +3,9 @@ package git import ( "fmt" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/plumbing" - "github.com/sirupsen/logrus" ) // Check if a branch exists in a repo. Use this and not repository.Branch(), @@ -90,11 +90,11 @@ func CheckoutDefaultBranch(repo *git.Repository, repoPath string) (plumbing.Refe } if err := worktree.Checkout(checkOutOpts); err != nil { - logrus.Debugf("failed to check out %s in %s", branch, repoPath) + log.Debugf("failed to check out %s in %s", branch, repoPath) return branch, err } - logrus.Debugf("successfully checked out %v in %s", branch, repoPath) + log.Debugf("successfully checked out %v in %s", branch, repoPath) return branch, nil } diff --git a/pkg/git/clone.go b/pkg/git/clone.go index d9ff190de..c295766f9 100644 --- a/pkg/git/clone.go +++ b/pkg/git/clone.go @@ -6,15 +6,15 @@ import ( "path/filepath" "strings" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/plumbing" - "github.com/sirupsen/logrus" ) // Clone runs a git clone which accounts for different default branches. func Clone(dir, url string) error { if _, err := os.Stat(dir); os.IsNotExist(err) { - logrus.Debugf("%s does not exist, attempting to git clone from %s", dir, url) + log.Debugf("%s does not exist, attempting to git clone from %s", dir, url) _, err := git.PlainClone(dir, false, &git.CloneOptions{ URL: url, @@ -23,7 +23,7 @@ func Clone(dir, url string) error { SingleBranch: true, }) if err != nil { - logrus.Debugf("cloning %s default branch failed, attempting from main branch", url) + log.Debugf("cloning %s default branch failed, attempting from main branch", url) _, err := git.PlainClone(dir, false, &git.CloneOptions{ URL: url, @@ -41,9 +41,9 @@ func Clone(dir, url string) error { } } - logrus.Debugf("%s has been git cloned successfully", dir) + log.Debugf("%s has been git cloned successfully", dir) } else { - logrus.Debugf("%s already exists", dir) + log.Debugf("%s already exists", dir) } return nil diff --git a/pkg/git/commit.go b/pkg/git/commit.go index 4b0e554b0..7775e518c 100644 --- a/pkg/git/commit.go +++ b/pkg/git/commit.go @@ -3,8 +3,8 @@ package git import ( "fmt" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" - "github.com/sirupsen/logrus" ) // Commit runs a git commit @@ -38,9 +38,9 @@ func Commit(repoPath, commitMessage string, dryRun bool) error { if err != nil { return err } - logrus.Debug("git changes commited") + log.Debug("git changes commited") } else { - logrus.Debug("dry run: no changes commited") + log.Debug("dry run: no changes commited") } return nil diff --git a/pkg/git/diff.go b/pkg/git/diff.go index 65a658f81..6242d6544 100644 --- a/pkg/git/diff.go +++ b/pkg/git/diff.go @@ -4,7 +4,7 @@ import ( "fmt" "os/exec" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" ) // getGitDiffArgs builds the `git diff` invocation args. It removes the usage @@ -26,7 +26,7 @@ func getGitDiffArgs(repoPath string) []string { // skips if it cannot find the command on the system. func DiffUnstaged(path string) error { if _, err := exec.LookPath("git"); err != nil { - logrus.Warnf("unable to locate git command, cannot output diff") + log.Warnf("unable to locate git command, cannot output diff") return nil } diff --git a/pkg/git/init.go b/pkg/git/init.go index 00d3c2e35..fe262780e 100644 --- a/pkg/git/init.go +++ b/pkg/git/init.go @@ -3,9 +3,9 @@ package git import ( "fmt" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/plumbing/object" - "github.com/sirupsen/logrus" ) // Init inits a new repo and commits all the stuff if you want @@ -13,7 +13,7 @@ func Init(repoPath string, commit bool, gitName, gitEmail string) error { if _, err := git.PlainInit(repoPath, false); err != nil { return fmt.Errorf("git init: %s", err) } - logrus.Debugf("initialised new git repo in %s", repoPath) + log.Debugf("initialised new git repo in %s", repoPath) if commit { commitRepo, err := git.PlainOpen(repoPath) @@ -37,7 +37,7 @@ func Init(repoPath string, commit bool, gitName, gitEmail string) error { if _, err = commitWorktree.Commit("init", &git.CommitOptions{Author: author}); err != nil { return fmt.Errorf("git commit: %s", err) } - logrus.Debugf("init committed all files for new git repo in %s", repoPath) + log.Debugf("init committed all files for new git repo in %s", repoPath) } return nil diff --git a/pkg/git/push.go b/pkg/git/push.go index 0430d57f1..9d279e659 100644 --- a/pkg/git/push.go +++ b/pkg/git/push.go @@ -1,15 +1,15 @@ package git import ( + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/config" - "github.com/sirupsen/logrus" ) // Push pushes the latest changes & optionally tags to the default remote func Push(repoDir string, remote string, tags bool, dryRun bool) error { if dryRun { - logrus.Debugf("dry run: no git changes pushed in %s", repoDir) + log.Debugf("dry run: no git changes pushed in %s", repoDir) return nil } @@ -27,7 +27,7 @@ func Push(repoDir string, remote string, tags bool, dryRun bool) error { return err } - logrus.Debugf("git changes pushed") + log.Debugf("git changes pushed") if tags { opts.RefSpecs = append(opts.RefSpecs, config.RefSpec("+refs/tags/*:refs/tags/*")) @@ -36,7 +36,7 @@ func Push(repoDir string, remote string, tags bool, dryRun bool) error { return err } - logrus.Debugf("git tags pushed") + log.Debugf("git tags pushed") } return nil diff --git a/pkg/git/read.go b/pkg/git/read.go index 47d74d338..ad104c74f 100644 --- a/pkg/git/read.go +++ b/pkg/git/read.go @@ -9,11 +9,11 @@ import ( "strings" "coopcloud.tech/abra/pkg/config" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" gitConfigPkg "github.com/go-git/go-git/v5/config" "github.com/go-git/go-git/v5/plumbing" "github.com/go-git/go-git/v5/plumbing/format/gitignore" - "github.com/sirupsen/logrus" ) // GetRecipeHead retrieves latest HEAD metadata. @@ -60,9 +60,9 @@ func IsClean(repoPath string) (bool, error) { } if status.String() != "" { - logrus.Debugf("discovered git status in %s: %s", repoPath, status.String()) + log.Debugf("discovered git status in %s: %s", repoPath, status.String()) } else { - logrus.Debugf("discovered clean git status in %s", repoPath) + log.Debugf("discovered clean git status in %s", repoPath) } return status.IsClean(), nil @@ -98,7 +98,7 @@ func parseGitConfig() (*gitConfigPkg.Config, error) { globalGitConfig := filepath.Join(usr.HomeDir, ".gitconfig") if _, err := os.Stat(globalGitConfig); err != nil { if os.IsNotExist(err) { - logrus.Debugf("no %s exists, not reading any global gitignore config", globalGitConfig) + log.Debugf("no %s exists, not reading any global gitignore config", globalGitConfig) return cfg, nil } return cfg, err @@ -140,7 +140,7 @@ func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) { if _, err := os.Stat(excludesfile); err != nil { if os.IsNotExist(err) { - logrus.Debugf("no %s exists, skipping reading gitignore paths", excludesfile) + log.Debugf("no %s exists, skipping reading gitignore paths", excludesfile) return ps, nil } return ps, err @@ -159,7 +159,7 @@ func parseExcludesFile(excludesfile string) ([]gitignore.Pattern, error) { } } - logrus.Debugf("read global ignore paths: %s", strings.Join(pathsRaw, " ")) + log.Debugf("read global ignore paths: %s", strings.Join(pathsRaw, " ")) return ps, nil } diff --git a/pkg/git/remote.go b/pkg/git/remote.go index 0d3c995b4..5d7d7af42 100644 --- a/pkg/git/remote.go +++ b/pkg/git/remote.go @@ -3,15 +3,15 @@ package git import ( "strings" + "coopcloud.tech/abra/pkg/log" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/config" - "github.com/sirupsen/logrus" ) // CreateRemote creates a new git remote in a repository func CreateRemote(repo *git.Repository, name, url string, dryRun bool) error { if dryRun { - logrus.Debugf("dry run: remote %s (%s) not created", name, url) + log.Debugf("dry run: remote %s (%s) not created", name, url) return nil } diff --git a/pkg/lint/recipe.go b/pkg/lint/recipe.go index 175e98afb..52f24522f 100644 --- a/pkg/lint/recipe.go +++ b/pkg/lint/recipe.go @@ -8,13 +8,13 @@ import ( "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/envfile" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" recipePkg "coopcloud.tech/abra/pkg/recipe" "coopcloud.tech/tagcmp" "github.com/distribution/reference" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/plumbing" - "github.com/sirupsen/logrus" ) var Warn = "warn" @@ -47,10 +47,10 @@ func (l LintRule) Skip(recipe recipe.Recipe) bool { if l.SkipCondition != nil { ok, err := l.SkipCondition(recipe) if err != nil { - logrus.Debugf("%s: skip condition: %s", l.Ref, err) + log.Debugf("%s: skip condition: %s", l.Ref, err) } if ok { - logrus.Debugf("skipping %s based on skip condition", l.Ref) + log.Debugf("skipping %s based on skip condition", l.Ref) return true } } @@ -175,7 +175,7 @@ var LintRules = map[string][]LintRule{ // used in code paths such as "app deploy" to avoid nasty surprises but not for // the typical linting commands, which do handle other levels. func LintForErrors(recipe recipe.Recipe) error { - logrus.Debugf("linting for critical errors in %s configs", recipe.Name) + log.Debugf("linting for critical errors in %s configs", recipe.Name) for level := range LintRules { if level != "error" { @@ -197,7 +197,7 @@ func LintForErrors(recipe recipe.Recipe) error { } } - logrus.Debugf("linting successful, %s is well configured", recipe.Name) + log.Debugf("linting successful, %s is well configured", recipe.Name) return nil } @@ -343,12 +343,12 @@ func LintImagePresent(recipe recipe.Recipe) (bool, error) { func LintHasPublishedVersion(recipe recipe.Recipe) (bool, error) { catl, err := recipePkg.ReadRecipeCatalogue(false) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } versions, err := recipePkg.GetRecipeCatalogueVersions(recipe.Name, catl) if err != nil { - logrus.Fatal(err) + log.Fatal(err) } if len(versions) == 0 { @@ -429,7 +429,7 @@ func LintValidTags(recipe recipe.Recipe) (bool, error) { iter, err := repo.Tags() if err != nil { - logrus.Fatalf("unable to list local tags for %s", recipe.Name) + log.Fatalf("unable to list local tags for %s", recipe.Name) } if err := iter.ForEach(func(ref *plumbing.Reference) error { diff --git a/pkg/recipe/recipe.go b/pkg/recipe/recipe.go index 8638a96ad..a112a256e 100644 --- a/pkg/recipe/recipe.go +++ b/pkg/recipe/recipe.go @@ -19,6 +19,7 @@ import ( "coopcloud.tech/abra/pkg/formatter" gitPkg "coopcloud.tech/abra/pkg/git" "coopcloud.tech/abra/pkg/limit" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/upstream/stack" loader "coopcloud.tech/abra/pkg/upstream/stack" "coopcloud.tech/abra/pkg/web" @@ -27,7 +28,6 @@ import ( composetypes "github.com/docker/cli/cli/compose/types" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/plumbing" - "github.com/sirupsen/logrus" ) // RecipeCatalogueURL is the only current recipe catalogue available. @@ -81,7 +81,7 @@ func (r RecipeMeta) LatestVersion() string { version = tag } - logrus.Debugf("choosing %s as latest version of %s", version, r.Name) + log.Debugf("choosing %s as latest version of %s", version, r.Name) return version } @@ -206,7 +206,7 @@ func (r Recipe) Tags() ([]string, error) { return tags, err } - logrus.Debugf("detected %s as tags for recipe %s", strings.Join(tags, ", "), r.Name) + log.Debugf("detected %s as tags for recipe %s", strings.Join(tags, ", "), r.Name) return tags, nil } @@ -284,7 +284,7 @@ func EnsureExists(recipeName string) error { recipeDir := path.Join(config.RECIPES_DIR, recipeName) if _, err := os.Stat(recipeDir); os.IsNotExist(err) { - logrus.Debugf("%s does not exist, attemmpting to clone", recipeDir) + log.Debugf("%s does not exist, attemmpting to clone", recipeDir) url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, recipeName) if err := gitPkg.Clone(recipeDir, url); err != nil { return err @@ -330,7 +330,7 @@ func EnsureVersion(recipeName, version string) error { joinedTags := strings.Join(parsedTags, ", ") if joinedTags != "" { - logrus.Debugf("read %s as tags for recipe %s", joinedTags, recipeName) + log.Debugf("read %s as tags for recipe %s", joinedTags, recipeName) } if tagRef.String() == "" { @@ -351,7 +351,7 @@ func EnsureVersion(recipeName, version string) error { return err } - logrus.Debugf("successfully checked %s out to %s in %s", recipeName, tagRef.Short(), recipeDir) + log.Debugf("successfully checked %s out to %s in %s", recipeName, tagRef.Short(), recipeDir) return nil } @@ -403,7 +403,7 @@ func EnsureLatest(recipeName string) error { } if err := worktree.Checkout(checkOutOpts); err != nil { - logrus.Debugf("failed to check out %s in %s", branch, recipeDir) + log.Debugf("failed to check out %s in %s", branch, recipeDir) return err } @@ -472,7 +472,7 @@ func GetRecipeFeaturesAndCategory(recipeName string) (Features, string, error) { readmePath := path.Join(config.RECIPES_DIR, recipeName, "README.md") - logrus.Debugf("attempting to open %s for recipe metadata parsing", readmePath) + log.Debugf("attempting to open %s for recipe metadata parsing", readmePath) readmeFS, err := ioutil.ReadFile(readmePath) if err != nil { @@ -553,9 +553,9 @@ func GetImageMetadata(imageRowString, recipeName string) (Image, error) { if len(imgFields) < 3 { if imageRowString != "" { - logrus.Warnf("%s image meta has incorrect format: %s", recipeName, imageRowString) + log.Warnf("%s image meta has incorrect format: %s", recipeName, imageRowString) } else { - logrus.Warnf("%s image meta is empty?", recipeName) + log.Warnf("%s image meta is empty?", recipeName) } return img, nil } @@ -567,13 +567,13 @@ func GetImageMetadata(imageRowString, recipeName string) (Image, error) { imageName, err := GetStringInBetween(recipeName, imgString, "[", "]") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } img.Image = strings.ReplaceAll(imageName, "`", "") imageURL, err := GetStringInBetween(recipeName, imgString, "(", ")") if err != nil { - logrus.Fatal(err) + log.Fatal(err) } img.URL = imageURL @@ -612,7 +612,7 @@ func EnsureUpToDate(recipeName string) error { } if len(remotes) == 0 { - logrus.Debugf("cannot ensure %s is up-to-date, no git remotes configured", recipeName) + log.Debugf("cannot ensure %s is up-to-date, no git remotes configured", recipeName) return nil } @@ -645,7 +645,7 @@ func EnsureUpToDate(recipeName string) error { } } - logrus.Debugf("fetched latest git changes for %s", recipeName) + log.Debugf("fetched latest git changes for %s", recipeName) return nil } @@ -682,7 +682,7 @@ func readRecipeCatalogueFS(target interface{}) error { return err } - logrus.Debugf("read recipe catalogue from file system cache in %s", config.RECIPES_JSON) + log.Debugf("read recipe catalogue from file system cache in %s", config.RECIPES_JSON) return nil } @@ -711,7 +711,7 @@ func VersionsOfService(recipe, serviceName string, offline bool) ([]string, erro } } - logrus.Debugf("detected versions %s for %s", strings.Join(versions, ", "), recipe) + log.Debugf("detected versions %s for %s", strings.Join(versions, ", "), recipe) return versions, nil } @@ -738,7 +738,7 @@ func GetRecipeMeta(recipeName string, offline bool) (RecipeMeta, error) { } } - logrus.Debugf("recipe metadata retrieved for %s", recipeName) + log.Debugf("recipe metadata retrieved for %s", recipeName) return recipeMeta, nil } @@ -831,7 +831,7 @@ func ReadReposMetadata() (RepoCatalogue, error) { pagedURL := fmt.Sprintf("%s?page=%v", ReposMetadataURL, pageIdx) - logrus.Debugf("fetching repo metadata from %s", pagedURL) + log.Debugf("fetching repo metadata from %s", pagedURL) if err := web.ReadJSON(pagedURL, &reposList); err != nil { return reposMeta, err @@ -869,7 +869,7 @@ func GetRecipeVersions(recipeName string, offline bool) (RecipeVersions, error) versions := RecipeVersions{} recipeDir := path.Join(config.RECIPES_DIR, recipeName) - logrus.Debugf("attempting to open git repository in %s", recipeDir) + log.Debugf("attempting to open git repository in %s", recipeDir) repo, err := git.PlainOpen(recipeDir) if err != nil { @@ -889,7 +889,7 @@ func GetRecipeVersions(recipeName string, offline bool) (RecipeVersions, error) if err := gitTags.ForEach(func(ref *plumbing.Reference) (err error) { tag := strings.TrimPrefix(string(ref.Name()), "refs/tags/") - logrus.Debugf("processing %s for %s", tag, recipeName) + log.Debugf("processing %s for %s", tag, recipeName) checkOutOpts := &git.CheckoutOptions{ Create: false, @@ -897,11 +897,11 @@ func GetRecipeVersions(recipeName string, offline bool) (RecipeVersions, error) Branch: plumbing.ReferenceName(ref.Name()), } if err := worktree.Checkout(checkOutOpts); err != nil { - logrus.Debugf("failed to check out %s in %s", tag, recipeDir) + log.Debugf("failed to check out %s in %s", tag, recipeDir) return err } - logrus.Debugf("successfully checked out %s in %s", ref.Name(), recipeDir) + log.Debugf("successfully checked out %s in %s", ref.Name(), recipeDir) recipe, err := Get(recipeName, offline) if err != nil { @@ -925,7 +925,7 @@ func GetRecipeVersions(recipeName string, offline bool) (RecipeVersions, error) case reference.NamedTagged: tag = img.(reference.NamedTagged).Tag() case reference.Named: - logrus.Warnf("%s service is missing image tag?", path) + log.Warnf("%s service is missing image tag?", path) continue } @@ -949,7 +949,7 @@ func GetRecipeVersions(recipeName string, offline bool) (RecipeVersions, error) sortRecipeVersions(versions) - logrus.Debugf("collected %s for %s", versions, recipeName) + log.Debugf("collected %s for %s", versions, recipeName) return versions, nil } @@ -1036,7 +1036,7 @@ func UpdateRepositories(repos RepoCatalogue, recipeName string) error { recipeDir := path.Join(config.RECIPES_DIR, rm.Name) if err := gitPkg.Clone(recipeDir, rm.CloneURL); err != nil { - logrus.Fatal(err) + log.Fatal(err) } ch <- rm.Name @@ -1076,7 +1076,7 @@ func GetComposeFiles(recipe string, appEnv map[string]string) ([]string, error) if err := ensurePathExists(path); err != nil { return composeFiles, err } - logrus.Debugf("no COMPOSE_FILE detected, loading default: %s", path) + log.Debugf("no COMPOSE_FILE detected, loading default: %s", path) composeFiles = append(composeFiles, path) return composeFiles, nil } @@ -1086,7 +1086,7 @@ func GetComposeFiles(recipe string, appEnv map[string]string) ([]string, error) if err := ensurePathExists(path); err != nil { return composeFiles, err } - logrus.Debugf("COMPOSE_FILE detected, loading %s", path) + log.Debugf("COMPOSE_FILE detected, loading %s", path) composeFiles = append(composeFiles, path) return composeFiles, nil } @@ -1105,8 +1105,8 @@ func GetComposeFiles(recipe string, appEnv map[string]string) ([]string, error) composeFiles = append(composeFiles, path) } - logrus.Debugf("COMPOSE_FILE detected (%s), loading %s", composeFileEnvVar, strings.Join(envVars, ", ")) - logrus.Debugf("retrieved %s configs for %s", strings.Join(composeFiles, ", "), recipe) + log.Debugf("COMPOSE_FILE detected (%s), loading %s", composeFileEnvVar, strings.Join(envVars, ", ")) + log.Debugf("retrieved %s configs for %s", strings.Join(composeFiles, ", "), recipe) return composeFiles, nil } diff --git a/pkg/secret/pass.go b/pkg/secret/pass.go index 7015936c4..1763e1f4c 100644 --- a/pkg/secret/pass.go +++ b/pkg/secret/pass.go @@ -5,7 +5,7 @@ import ( "fmt" "os/exec" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" ) // PassInsertSecret inserts a secret into a pass store. @@ -19,13 +19,13 @@ func PassInsertSecret(secretValue, secretName, appName, server string) error { secretValue, server, appName, secretName, ) - logrus.Debugf("attempting to run %s", cmd) + log.Debugf("attempting to run %s", cmd) if err := exec.Command("bash", "-c", cmd).Run(); err != nil { return err } - logrus.Infof("%s inserted into pass store", secretName) + log.Infof("%s inserted into pass store", secretName) return nil } @@ -41,13 +41,13 @@ func PassRmSecret(secretName, appName, server string) error { server, appName, secretName, ) - logrus.Debugf("attempting to run %s", cmd) + log.Debugf("attempting to run %s", cmd) if err := exec.Command("bash", "-c", cmd).Run(); err != nil { return err } - logrus.Infof("%s removed from pass store", secretName) + log.Infof("%s removed from pass store", secretName) return nil } diff --git a/pkg/secret/secret.go b/pkg/secret/secret.go index 9e7ff09db..fd69508ac 100644 --- a/pkg/secret/secret.go +++ b/pkg/secret/secret.go @@ -15,13 +15,13 @@ import ( "coopcloud.tech/abra/pkg/client" "coopcloud.tech/abra/pkg/config" "coopcloud.tech/abra/pkg/envfile" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/recipe" "coopcloud.tech/abra/pkg/upstream/stack" loader "coopcloud.tech/abra/pkg/upstream/stack" "github.com/decentral1se/passgen" "github.com/docker/docker/api/types" dockerClient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // Secret represents a secret. @@ -55,7 +55,7 @@ func GeneratePasswords(count, length uint) ([]string, error) { return nil, err } - logrus.Debugf("generated %s", strings.Join(passwords, ", ")) + log.Debugf("generated %s", strings.Join(passwords, ", ")) return passwords, nil } @@ -73,7 +73,7 @@ func GeneratePassphrases(count uint) ([]string, error) { return nil, err } - logrus.Debugf("generated %s", strings.Join(passphrases, ", ")) + log.Debugf("generated %s", strings.Join(passphrases, ", ")) return passphrases, nil } @@ -110,7 +110,7 @@ func ReadSecretsConfig(appEnvPath string, composeFiles []string, stackName strin } if len(enabledSecrets) == 0 { - logrus.Debugf("not generating app secrets, none enabled in recipe config") + log.Debugf("not generating app secrets, none enabled in recipe config") return nil, nil } @@ -121,7 +121,7 @@ func ReadSecretsConfig(appEnvPath string, composeFiles []string, stackName strin } if !(slices.Contains(enabledSecrets, secretId)) { - logrus.Warnf("%s not enabled in recipe config, skipping", secretId) + log.Warnf("%s not enabled in recipe config, skipping", secretId) continue } @@ -171,7 +171,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server go func(secretName string, secret Secret) { defer wg.Done() - logrus.Debugf("attempting to generate and store %s on %s", secret.RemoteName, server) + log.Debugf("attempting to generate and store %s on %s", secret.RemoteName, server) if secret.Length > 0 { passwords, err := GeneratePasswords(1, uint(secret.Length)) @@ -182,7 +182,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server if err := client.StoreSecret(cl, secret.RemoteName, passwords[0], server); err != nil { if strings.Contains(err.Error(), "AlreadyExists") { - logrus.Warnf("%s already exists, moving on...", secret.RemoteName) + log.Warnf("%s already exists, moving on...", secret.RemoteName) ch <- nil } else { ch <- err @@ -202,7 +202,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server if err := client.StoreSecret(cl, secret.RemoteName, passphrases[0], server); err != nil { if strings.Contains(err.Error(), "AlreadyExists") { - logrus.Warnf("%s already exists, moving on...", secret.RemoteName) + log.Warnf("%s already exists, moving on...", secret.RemoteName) ch <- nil } else { ch <- err @@ -227,7 +227,7 @@ func GenerateSecrets(cl *dockerClient.Client, secrets map[string]Secret, server } } - logrus.Debugf("generated and stored %v on %s", secrets, server) + log.Debugf("generated and stored %v on %s", secrets, server) return secretsGenerated, nil } diff --git a/pkg/server/server.go b/pkg/server/server.go index c8e4b9823..56c4eaa00 100644 --- a/pkg/server/server.go +++ b/pkg/server/server.go @@ -5,7 +5,7 @@ import ( "path" "coopcloud.tech/abra/pkg/config" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" ) // CreateServerDir creates a server directory under ~/.abra. @@ -17,11 +17,11 @@ func CreateServerDir(serverName string) error { return err } - logrus.Debugf("%s already exists", serverPath) + log.Debugf("%s already exists", serverPath) return nil } - logrus.Debugf("successfully created %s", serverPath) + log.Debugf("successfully created %s", serverPath) return nil } diff --git a/pkg/service/service.go b/pkg/service/service.go index 48cdce759..32d1f8f68 100644 --- a/pkg/service/service.go +++ b/pkg/service/service.go @@ -6,12 +6,12 @@ import ( "strings" "coopcloud.tech/abra/pkg/formatter" + "coopcloud.tech/abra/pkg/log" "github.com/AlecAivazis/survey/v2" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // GetService retrieves a service container based on a label. If prompt is true @@ -52,7 +52,7 @@ func GetServiceByLabel(c context.Context, cl *client.Client, label string, promp return swarm.Service{}, err } - logrus.Warnf("ambiguous service list received, prompting for input") + log.Warnf("ambiguous service list received, prompting for input") var response string prompt := &survey.Select{ @@ -72,7 +72,7 @@ func GetServiceByLabel(c context.Context, cl *client.Client, label string, promp } } - logrus.Panic("failed to match chosen service") + log.Fatal("failed to match chosen service") } return matchingServices[0], nil @@ -106,7 +106,7 @@ func GetService(c context.Context, cl *client.Client, filters filters.Args, prom return swarm.Service{}, err } - logrus.Warnf("ambiguous service list received, prompting for input") + log.Warnf("ambiguous service list received, prompting for input") var response string prompt := &survey.Select{ @@ -126,7 +126,7 @@ func GetService(c context.Context, cl *client.Client, filters filters.Args, prom } } - logrus.Panic("failed to match chosen service") + log.Fatal("failed to match chosen service") } return services[0], nil diff --git a/pkg/test/test.go b/pkg/test/test.go index 70bb1cae3..a9f2593a4 100644 --- a/pkg/test/test.go +++ b/pkg/test/test.go @@ -1,13 +1,12 @@ package test import ( - "log" "os" "path" appPkg "coopcloud.tech/abra/pkg/app" "coopcloud.tech/abra/pkg/envfile" - "github.com/sirupsen/logrus" + "coopcloud.tech/abra/pkg/log" ) var ( @@ -53,12 +52,12 @@ var ExpectedAppFiles = map[string]appPkg.AppFile{ func RmServerAppRecipe() { testAppLink := os.ExpandEnv("$HOME/.abra/servers/foo.com") if err := os.Remove(testAppLink); err != nil { - logrus.Fatal(err) + log.Fatal(err) } testRecipeLink := os.ExpandEnv("$HOME/.abra/recipes/test") if err := os.Remove(testRecipeLink); err != nil { - logrus.Fatal(err) + log.Fatal(err) } } diff --git a/pkg/upstream/commandconn/commandconn.go b/pkg/upstream/commandconn/commandconn.go index 31074183c..9f76c50f4 100644 --- a/pkg/upstream/commandconn/commandconn.go +++ b/pkg/upstream/commandconn/commandconn.go @@ -27,8 +27,8 @@ import ( "syscall" "time" + "coopcloud.tech/abra/pkg/log" "github.com/pkg/errors" - "github.com/sirupsen/logrus" exec "golang.org/x/sys/execabs" ) @@ -46,7 +46,7 @@ func New(ctx context.Context, cmd string, args ...string) (net.Conn, error) { ) c.cmd = exec.CommandContext(ctx, cmd, args...) // we assume that args never contains sensitive information - logrus.Debugf("commandconn: starting %s with %v", cmd, args) + log.Debugf("commandconn: starting %s with %v", cmd, args) c.cmd.Env = os.Environ() c.cmd.SysProcAttr = &syscall.SysProcAttr{} setPdeathsig(c.cmd) @@ -189,14 +189,14 @@ func (c *commandConn) CloseRead() error { // NOTE: maybe already closed here if err := c.stdout.Close(); err != nil && !ignorableCloseError(err) { // muted because https://github.com/docker/compose/issues/8544 - // logrus.Warnf("commandConn.CloseRead: %v", err) + // log.Warnf("commandConn.CloseRead: %v", err) } c.stdioClosedMu.Lock() c.stdoutClosed = true c.stdioClosedMu.Unlock() if err := c.killIfStdioClosed(); err != nil { // muted because https://github.com/docker/compose/issues/8544 - // logrus.Warnf("commandConn.CloseRead: %v", err) + // log.Warnf("commandConn.CloseRead: %v", err) } return nil } @@ -213,14 +213,14 @@ func (c *commandConn) CloseWrite() error { // NOTE: maybe already closed here if err := c.stdin.Close(); err != nil && !ignorableCloseError(err) { // muted because https://github.com/docker/compose/issues/8544 - // logrus.Warnf("commandConn.CloseWrite: %v", err) + // log.Warnf("commandConn.CloseWrite: %v", err) } c.stdioClosedMu.Lock() c.stdinClosed = true c.stdioClosedMu.Unlock() if err := c.killIfStdioClosed(); err != nil { // muted because https://github.com/docker/compose/issues/8544 - // logrus.Warnf("commandConn.CloseWrite: %v", err) + // log.Warnf("commandConn.CloseWrite: %v", err) } return nil } @@ -236,11 +236,11 @@ func (c *commandConn) Write(p []byte) (int, error) { func (c *commandConn) Close() error { var err error if err = c.CloseRead(); err != nil { - logrus.Warnf("commandConn.Close: CloseRead: %v", err) + log.Warnf("commandConn.Close: CloseRead: %v", err) } if err = c.CloseWrite(); err != nil { // muted because https://github.com/docker/compose/issues/8544 - // logrus.Warnf("commandConn.Close: CloseWrite: %v", err) + // log.Warnf("commandConn.Close: CloseWrite: %v", err) } return err } @@ -252,15 +252,15 @@ func (c *commandConn) RemoteAddr() net.Addr { return c.remoteAddr } func (c *commandConn) SetDeadline(t time.Time) error { - logrus.Debugf("unimplemented call: SetDeadline(%v)", t) + log.Debugf("unimplemented call: SetDeadline(%v)", t) return nil } func (c *commandConn) SetReadDeadline(t time.Time) error { - logrus.Debugf("unimplemented call: SetReadDeadline(%v)", t) + log.Debugf("unimplemented call: SetReadDeadline(%v)", t) return nil } func (c *commandConn) SetWriteDeadline(t time.Time) error { - logrus.Debugf("unimplemented call: SetWriteDeadline(%v)", t) + log.Debugf("unimplemented call: SetWriteDeadline(%v)", t) return nil } @@ -284,7 +284,7 @@ type stderrWriter struct { } func (w *stderrWriter) Write(p []byte) (int, error) { - logrus.Debugf("%s%s", w.debugPrefix, string(p)) + log.Debugf("%s%s", w.debugPrefix, string(p)) w.stderrMu.Lock() if w.stderr.Len() > 4096 { w.stderr.Reset() diff --git a/pkg/upstream/container/exec.go b/pkg/upstream/container/exec.go index 82a2c5705..584b92067 100644 --- a/pkg/upstream/container/exec.go +++ b/pkg/upstream/container/exec.go @@ -6,11 +6,11 @@ import ( "fmt" "io" + "coopcloud.tech/abra/pkg/log" "github.com/docker/cli/cli" "github.com/docker/cli/cli/command" "github.com/docker/docker/api/types" apiclient "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // RunExec runs a command on a remote container. io.Writer corresponds to the @@ -109,7 +109,7 @@ func interactiveExec(ctx context.Context, dockerCli command.Cli, client *apiclie } if err := <-errCh; err != nil { - logrus.Debugf("Error hijack: %s", err) + log.Debugf("Error hijack: %s", err) return out, err } diff --git a/pkg/upstream/container/hijack.go b/pkg/upstream/container/hijack.go index 3f3cd42f2..f2a9990eb 100644 --- a/pkg/upstream/container/hijack.go +++ b/pkg/upstream/container/hijack.go @@ -7,12 +7,12 @@ import ( "runtime" "sync" + "coopcloud.tech/abra/pkg/log" "github.com/docker/cli/cli/command" "github.com/docker/docker/api/types" "github.com/docker/docker/pkg/ioutils" "github.com/docker/docker/pkg/stdcopy" "github.com/moby/term" - "github.com/sirupsen/logrus" ) // The default escape key sequence: ctrl-p, ctrl-q @@ -96,7 +96,7 @@ func (h *hijackedIOStreamer) setupInput() (restore func(), err error) { if h.detachKeys != "" { customEscapeKeys, err := term.ToBytes(h.detachKeys) if err != nil { - logrus.Warnf("invalid detach escape keys, using default: %s", err) + log.Warnf("invalid detach escape keys, using default: %s", err) } else { escapeKeys = customEscapeKeys } @@ -128,10 +128,10 @@ func (h *hijackedIOStreamer) beginOutputStream(restoreInput func()) <-chan error _, err = stdcopy.StdCopy(h.outputStream, h.errorStream, h.resp.Reader) } - logrus.Debug("[hijack] End of stdout") + log.Debug("[hijack] End of stdout") if err != nil { - logrus.Debugf("Error receiveStdout: %s", err) + log.Debugf("Error receiveStdout: %s", err) } outputDone <- err @@ -152,7 +152,7 @@ func (h *hijackedIOStreamer) beginInputStream(restoreInput func()) (doneC <-chan // messages will be in normal type. restoreInput() - logrus.Debug("[hijack] End of stdin") + log.Debug("[hijack] End of stdin") if _, ok := err.(term.EscapeError); ok { detached <- err @@ -163,12 +163,12 @@ func (h *hijackedIOStreamer) beginInputStream(restoreInput func()) (doneC <-chan // This error will also occur on the receive // side (from stdout) where it will be // propagated back to the caller. - logrus.Debugf("Error sendStdin: %s", err) + log.Debugf("Error sendStdin: %s", err) } } if err := h.resp.CloseWrite(); err != nil { - logrus.Debugf("Couldn't send EOF: %s", err) + log.Debugf("Couldn't send EOF: %s", err) } close(inputDone) diff --git a/pkg/upstream/container/tty.go b/pkg/upstream/container/tty.go index 158aa5357..2a5a55ae0 100644 --- a/pkg/upstream/container/tty.go +++ b/pkg/upstream/container/tty.go @@ -8,12 +8,12 @@ import ( "runtime" "time" + "coopcloud.tech/abra/pkg/log" "github.com/docker/cli/cli/command" "github.com/docker/docker/api/types/container" "github.com/docker/docker/client" apiclient "github.com/docker/docker/client" "github.com/moby/sys/signal" - "github.com/sirupsen/logrus" ) // resizeTtyTo resizes tty to specific height and width @@ -35,7 +35,7 @@ func resizeTtyTo(ctx context.Context, client client.ContainerAPIClient, id strin } if err != nil { - logrus.Debugf("Error resize: %s\r", err) + log.Debugf("Error resize: %s\r", err) } return err } diff --git a/pkg/upstream/service/scale.go b/pkg/upstream/service/scale.go index 0a483fac4..ed7c2ad1d 100644 --- a/pkg/upstream/service/scale.go +++ b/pkg/upstream/service/scale.go @@ -4,9 +4,9 @@ import ( "context" "fmt" + "coopcloud.tech/abra/pkg/log" "github.com/docker/docker/api/types" "github.com/docker/docker/client" - "github.com/sirupsen/logrus" ) // RunServiceScale scales a service (useful for restart action) @@ -37,7 +37,7 @@ func RunServiceScale(ctx context.Context, cl *client.Client, serviceID string, s } for _, warning := range response.Warnings { - logrus.Warn(warning) + log.Warn(warning) } return nil diff --git a/pkg/upstream/stack/loader.go b/pkg/upstream/stack/loader.go index 9790903f9..ab0e609e4 100644 --- a/pkg/upstream/stack/loader.go +++ b/pkg/upstream/stack/loader.go @@ -7,10 +7,10 @@ import ( "sort" "strings" + "coopcloud.tech/abra/pkg/log" "github.com/docker/cli/cli/compose/loader" "github.com/docker/cli/cli/compose/schema" composetypes "github.com/docker/cli/cli/compose/types" - "github.com/sirupsen/logrus" ) // DontSkipValidation ensures validation is done for compose file loading @@ -51,13 +51,13 @@ func LoadComposefile(opts Deploy, appEnv map[string]string, options ...func(*loa unsupportedProperties := loader.GetUnsupportedProperties(dicts...) if len(unsupportedProperties) > 0 { - logrus.Warnf("%s: ignoring unsupported options: %s", + log.Warnf("%s: ignoring unsupported options: %s", recipeName, strings.Join(unsupportedProperties, ", ")) } deprecatedProperties := loader.GetDeprecatedProperties(dicts...) if len(deprecatedProperties) > 0 { - logrus.Warnf("%s: ignoring deprecated options: %s", + log.Warnf("%s: ignoring deprecated options: %s", recipeName, propertyWarnings(deprecatedProperties)) } return config, nil diff --git a/pkg/upstream/stack/remove.go b/pkg/upstream/stack/remove.go index 7c211b565..81584ba4d 100644 --- a/pkg/upstream/stack/remove.go +++ b/pkg/upstream/stack/remove.go @@ -6,13 +6,13 @@ import ( "sort" "strings" + "coopcloud.tech/abra/pkg/log" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/api/types/versions" "github.com/docker/docker/client" apiclient "github.com/docker/docker/client" "github.com/pkg/errors" - "github.com/sirupsen/logrus" ) // RunRemove is the swarm implementation of docker stack remove @@ -46,7 +46,7 @@ func RunRemove(ctx context.Context, client *apiclient.Client, opts Remove) error } if len(services)+len(networks)+len(secrets)+len(configs) == 0 { - logrus.Warning(fmt.Errorf("nothing found in stack: %s", namespace)) + log.Warnf("nothing found in stack: %s", namespace) continue } @@ -87,10 +87,10 @@ func removeServices( var hasError bool sort.Slice(services, sortServiceByName(services)) for _, service := range services { - logrus.Infof("removing service %s\n", service.Spec.Name) + log.Infof("removing service %s\n", service.Spec.Name) if err := client.ServiceRemove(ctx, service.ID); err != nil { hasError = true - logrus.Fatalf("failed to remove service %s: %s", service.ID, err) + log.Fatalf("failed to remove service %s: %s", service.ID, err) } } return hasError @@ -103,10 +103,10 @@ func removeNetworks( ) bool { var hasError bool for _, network := range networks { - logrus.Infof("removing network %s\n", network.Name) + log.Infof("removing network %s\n", network.Name) if err := client.NetworkRemove(ctx, network.ID); err != nil { hasError = true - logrus.Fatalf("failed to remove network %s: %s", network.ID, err) + log.Fatalf("failed to remove network %s: %s", network.ID, err) } } return hasError @@ -119,10 +119,10 @@ func removeSecrets( ) bool { var hasError bool for _, secret := range secrets { - logrus.Infof("Removing secret %s\n", secret.Spec.Name) + log.Infof("Removing secret %s\n", secret.Spec.Name) if err := client.SecretRemove(ctx, secret.ID); err != nil { hasError = true - logrus.Fatalf("Failed to remove secret %s: %s", secret.ID, err) + log.Fatalf("Failed to remove secret %s: %s", secret.ID, err) } } return hasError @@ -135,10 +135,10 @@ func removeConfigs( ) bool { var hasError bool for _, config := range configs { - logrus.Infof("removing config %s\n", config.Spec.Name) + log.Infof("removing config %s\n", config.Spec.Name) if err := client.ConfigRemove(ctx, config.ID); err != nil { hasError = true - logrus.Fatalf("failed to remove config %s: %s", config.ID, err) + log.Fatalf("failed to remove config %s: %s", config.ID, err) } } return hasError diff --git a/pkg/upstream/stack/stack.go b/pkg/upstream/stack/stack.go index d9dc94f3e..007adea76 100644 --- a/pkg/upstream/stack/stack.go +++ b/pkg/upstream/stack/stack.go @@ -11,6 +11,7 @@ import ( stdlibErr "errors" + "coopcloud.tech/abra/pkg/log" "coopcloud.tech/abra/pkg/upstream/convert" "github.com/docker/cli/cli/command/service/progress" "github.com/docker/cli/cli/command/stack/formatter" @@ -23,7 +24,6 @@ import ( "github.com/docker/docker/client" dockerClient "github.com/docker/docker/client" "github.com/pkg/errors" - "github.com/sirupsen/logrus" ) // Resolve image constants @@ -118,12 +118,12 @@ func IsDeployed(ctx context.Context, cl *dockerClient.Client, stackName string) } } - logrus.Debugf("%s has been detected as deployed with version %s", stackName, version) + log.Debugf("%s has been detected as deployed with version %s", stackName, version) return true, version, nil } - logrus.Debugf("%s has been detected as not deployed", stackName) + log.Debugf("%s has been detected as not deployed", stackName) return isDeployed, version, nil } @@ -131,7 +131,7 @@ func IsDeployed(ctx context.Context, cl *dockerClient.Client, stackName string) func pruneServices(ctx context.Context, cl *dockerClient.Client, namespace convert.Namespace, services map[string]struct{}) { oldServices, err := GetStackServices(ctx, cl, namespace.Name()) if err != nil { - logrus.Infof("failed to list services: %s\n", err) + log.Infof("failed to list services: %s\n", err) } pruneServices := []swarm.Service{} @@ -213,9 +213,9 @@ func deployCompose(ctx context.Context, cl *dockerClient.Client, opts Deploy, co return err } - logrus.Infof("waiting for %s to deploy... please hold 🤚", appName) + log.Infof("waiting for %s to deploy... please hold 🤚", appName) if err := waitOnServices(ctx, cl, serviceIDs, appName); err == nil { - logrus.Infof("Successfully deployed %s", appName) + log.Infof("Successfully deployed %s", appName) } return err } @@ -265,7 +265,7 @@ func createSecrets(ctx context.Context, cl *dockerClient.Client, secrets []swarm } case dockerClient.IsErrNotFound(err): // secret does not exist, then we create a new one. - logrus.Infof("Creating secret %s\n", secretSpec.Name) + log.Infof("Creating secret %s\n", secretSpec.Name) if _, err := cl.SecretCreate(ctx, secretSpec); err != nil { return errors.Wrapf(err, "failed to create secret %s", secretSpec.Name) } @@ -287,7 +287,7 @@ func createConfigs(ctx context.Context, cl *dockerClient.Client, configs []swarm } case dockerClient.IsErrNotFound(err): // config does not exist, then we create a new one. - logrus.Infof("creating config %s\n", configSpec.Name) + log.Infof("creating config %s\n", configSpec.Name) if _, err := cl.ConfigCreate(ctx, configSpec); err != nil { return errors.Wrapf(err, "failed to create config %s", configSpec.Name) } @@ -318,7 +318,7 @@ func createNetworks(ctx context.Context, cl *dockerClient.Client, namespace conv createOpts.Driver = defaultNetworkDriver } - logrus.Infof("creating network %s\n", name) + log.Infof("creating network %s\n", name) if _, err := cl.NetworkCreate(ctx, name, createOpts); err != nil { return errors.Wrapf(err, "failed to create network %s", name) } @@ -355,7 +355,7 @@ func deployServices( ) if service, exists := existingServiceMap[name]; exists { - logrus.Infof("Updating service %s (id: %s)\n", name, service.ID) + log.Infof("Updating service %s (id: %s)\n", name, service.ID) updateOpts := types.ServiceUpdateOptions{EncodedRegistryAuth: encodedAuth} @@ -394,12 +394,12 @@ func deployServices( } for _, warning := range response.Warnings { - logrus.Warn(warning) + log.Warn(warning) } serviceIDs = append(serviceIDs, service.ID) } else { - logrus.Infof("creating service %s\n", name) + log.Infof("creating service %s\n", name) createOpts := types.ServiceCreateOptions{EncodedRegistryAuth: encodedAuth} @@ -418,7 +418,7 @@ func deployServices( } if dontWait { - logrus.Warn("skipping converge logic checks") + log.Warn("skipping converge logic checks") return nil, nil } diff --git a/pkg/web/client.go b/pkg/web/client.go index 6eb7fe5ea..9ecb4c797 100644 --- a/pkg/web/client.go +++ b/pkg/web/client.go @@ -3,18 +3,18 @@ package web import ( "fmt" + "coopcloud.tech/abra/pkg/log" "github.com/hashicorp/go-retryablehttp" - "github.com/sirupsen/logrus" ) -// customLeveledLogger is custom logger with logrus baked in +// customLeveledLogger is custom logger with custom logger baked in type customLeveledLogger struct { retryablehttp.Logger } -// Printf wires up logrus into the custom retryablehttp logger +// Printf wires up our existing custom logger into the custom retryablehttp logger func (l customLeveledLogger) Printf(msg string, args ...interface{}) { - logrus.Debugf(fmt.Sprintf(msg, args...)) + log.Debugf(fmt.Sprintf(msg, args...)) } // NewHTTPRetryClient instantiates a new http client with retries baked in