opensource/flux2
1
0
Fork 0
mirror of https://github.com/fluxcd/flux2.git synced 2025-11-01 18:26:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

Create logger interface

Browse Source
This commit is contained in:
Hidde Beydals
2020-06-25 17:31:58 +02:00
parent 5499d15402
commit 329e21fd78
21 changed files with 155 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/tk/bootstrap.go
View File

@ -179,7 +179,7 @@ func applySyncManifests(ctx context.Context, kubeClient client.Client, name, nam
return err
}
logWaiting("waiting for cluster sync")
logger.Waitingf("waiting for cluster sync")
if err := wait.PollImmediate(pollInterval, timeout,
isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {

32
cmd/tk/bootstrap_github.go
View File

@ -118,13 +118,13 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
defer cancel()
// create GitHub repository if doesn't exists
logAction("connecting to %s", ghHostname)
logger.Actionf("connecting to %s", ghHostname)
changed, err := provider.CreateRepository(ctx, repository)
if err != nil {
return err
}
if changed {
logSuccess("repository created")
logger.Successf("repository created")
}
withErrors := false
@ -132,10 +132,10 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
if !ghPersonal {
for _, team := range ghTeams {
if changed, err := provider.AddTeam(ctx, repository, team, ghDefaultPermission); err != nil {
logFailure(err.Error())
logger.Failuref(err.Error())
withErrors = true
} else if changed {
logSuccess("%s team access granted", team)
logger.Successf("%s team access granted", team)
}
}
}
@ -144,10 +144,10 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
if err := repository.Checkout(ctx, bootstrapBranch, tmpDir); err != nil {
return err
}
logSuccess("repository cloned")
logger.Successf("repository cloned")
// generate install manifests
logGenerate("generating manifests")
logger.Generatef("generating manifests")
manifest, err := generateInstallManifests(ghPath, namespace, tmpDir)
if err != nil {
return err
@ -164,9 +164,9 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
if err := repository.Push(ctx); err != nil {
return err
}
logSuccess("components manifests pushed")
logger.Successf("components manifests pushed")
} else {
logSuccess("components are up to date")
logger.Successf("components are up to date")
}
// determine if repo synchronization is working
@ -174,16 +174,16 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
if isInstall {
// apply install manifests
logAction("installing components in %s namespace", namespace)
logger.Actionf("installing components in %s namespace", namespace)
if err := applyInstallManifests(ctx, manifest, components); err != nil {
return err
}
logSuccess("install completed")
logger.Successf("install completed")
}
// setup SSH deploy key
if shouldCreateDeployKey(ctx, kubeClient, namespace) {
logAction("configuring deploy key")
logger.Actionf("configuring deploy key")
u, err := url.Parse(repository.GetSSH())
if err != nil {
return fmt.Errorf("git URL parse failed: %w", err)
@ -202,14 +202,14 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
if changed, err := provider.AddDeployKey(ctx, repository, key, keyName); err != nil {
return err
} else if changed {
logSuccess("deploy key configured")
logger.Successf("deploy key configured")
}
}
// configure repo synchronization
if isInstall {
// generate source and kustomization manifests
logAction("generating sync manifests")
logger.Actionf("generating sync manifests")
if err := generateSyncManifests(repository.GetSSH(), namespace, namespace, ghPath, tmpDir, ghInterval); err != nil {
return err
}
@ -221,11 +221,11 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
if err := repository.Push(ctx); err != nil {
return err
}
logSuccess("sync manifests pushed")
logger.Successf("sync manifests pushed")
}
// apply manifests and waiting for sync
logAction("applying sync manifests")
logger.Actionf("applying sync manifests")
if err := applySyncManifests(ctx, kubeClient, namespace, namespace, ghPath, tmpDir); err != nil {
return err
}
@ -235,6 +235,6 @@ func bootstrapGitHubCmdRun(cmd *cobra.Command, args []string) error {
return fmt.Errorf("bootstrap completed with errors")
}
logSuccess("bootstrap finished")
logger.Successf("bootstrap finished")
return nil
}

28
cmd/tk/bootstrap_gitlab.go
View File

@ -109,23 +109,23 @@ func bootstrapGitLabCmdRun(cmd *cobra.Command, args []string) error {
defer cancel()
// create GitLab project if doesn't exists
logAction("connecting to %s", glHostname)
logger.Actionf("connecting to %s", glHostname)
changed, err := provider.CreateRepository(ctx, repository)
if err != nil {
return err
}
if changed {
logSuccess("repository created")
logger.Successf("repository created")
}
// clone repository and checkout the master branch
if err := repository.Checkout(ctx, bootstrapBranch, tmpDir); err != nil {
return err
}
logSuccess("repository cloned")
logger.Successf("repository cloned")
// generate install manifests
logGenerate("generating manifests")
logger.Generatef("generating manifests")
manifest, err := generateInstallManifests(glPath, namespace, tmpDir)
if err != nil {
return err
@ -142,9 +142,9 @@ func bootstrapGitLabCmdRun(cmd *cobra.Command, args []string) error {
if err := repository.Push(ctx); err != nil {
return err
}
logSuccess("components manifests pushed")
logger.Successf("components manifests pushed")
} else {
logSuccess("components are up to date")
logger.Successf("components are up to date")
}
// determine if repo synchronization is working
@ -152,16 +152,16 @@ func bootstrapGitLabCmdRun(cmd *cobra.Command, args []string) error {
if isInstall {
// apply install manifests
logAction("installing components in %s namespace", namespace)
logger.Actionf("installing components in %s namespace", namespace)
if err := applyInstallManifests(ctx, manifest, components); err != nil {
return err
}
logSuccess("install completed")
logger.Successf("install completed")
}
// setup SSH deploy key
if shouldCreateDeployKey(ctx, kubeClient, namespace) {
logAction("configuring deploy key")
logger.Actionf("configuring deploy key")
u, err := url.Parse(repository.GetSSH())
if err != nil {
return fmt.Errorf("git URL parse failed: %w", err)
@ -180,14 +180,14 @@ func bootstrapGitLabCmdRun(cmd *cobra.Command, args []string) error {
if changed, err := provider.AddDeployKey(ctx, repository, key, keyName); err != nil {
return err
} else if changed {
logSuccess("deploy key configured")
logger.Successf("deploy key configured")
}
}
// configure repo synchronization
if isInstall {
// generate source and kustomization manifests
logAction("generating sync manifests")
logger.Actionf("generating sync manifests")
if err := generateSyncManifests(repository.GetSSH(), namespace, namespace, glPath, tmpDir, glInterval); err != nil {
return err
}
@ -199,16 +199,16 @@ func bootstrapGitLabCmdRun(cmd *cobra.Command, args []string) error {
if err := repository.Push(ctx); err != nil {
return err
}
logSuccess("sync manifests pushed")
logger.Successf("sync manifests pushed")
}
// apply manifests and waiting for sync
logAction("applying sync manifests")
logger.Actionf("applying sync manifests")
if err := applySyncManifests(ctx, kubeClient, namespace, namespace, glPath, tmpDir); err != nil {
return err
}
}
logSuccess("bootstrap finished")
logger.Successf("bootstrap finished")
return nil
}

34
cmd/tk/check.go
View File

@ -58,7 +58,7 @@ func runCheckCmd(cmd *cobra.Command, args []string) error {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
logAction("checking prerequisites")
logger.Actionf("checking prerequisites")
checkFailed := false
if !kubectlCheck(ctx, ">=1.18.0") {
@ -73,83 +73,83 @@ func runCheckCmd(cmd *cobra.Command, args []string) error {
if checkFailed {
os.Exit(1)
}
logSuccess("prerequisites checks passed")
logger.Successf("prerequisites checks passed")
return nil
}
logAction("checking controllers")
logger.Actionf("checking controllers")
if !componentsCheck() {
checkFailed = true
}
if checkFailed {
os.Exit(1)
}
logSuccess("all checks passed")
logger.Successf("all checks passed")
return nil
}
func kubectlCheck(ctx context.Context, version string) bool {
_, err := exec.LookPath("kubectl")
if err != nil {
logFailure("kubectl not found")
logger.Failuref("kubectl not found")
return false
}
command := "kubectl version --client --short | awk '{ print $3 }'"
output, err := utils.execCommand(ctx, ModeCapture, command)
if err != nil {
logFailure("kubectl version can't be determined")
logger.Failuref("kubectl version can't be determined")
return false
}
v, err := semver.ParseTolerant(output)
if err != nil {
logFailure("kubectl version can't be parsed")
logger.Failuref("kubectl version can't be parsed")
return false
}
rng, _ := semver.ParseRange(version)
if !rng(v) {
logFailure("kubectl version must be %s", version)
logger.Failuref("kubectl version must be %s", version)
return false
}
logSuccess("kubectl %s %s", v.String(), version)
logger.Successf("kubectl %s %s", v.String(), version)
return true
}
func kubernetesCheck(version string) bool {
cfg, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
if err != nil {
logFailure("Kubernetes client initialization failed: %s", err.Error())
logger.Failuref("Kubernetes client initialization failed: %s", err.Error())
return false
}
client, err := kubernetes.NewForConfig(cfg)
if err != nil {
logFailure("Kubernetes client initialization failed: %s", err.Error())
logger.Failuref("Kubernetes client initialization failed: %s", err.Error())
return false
}
ver, err := client.Discovery().ServerVersion()
if err != nil {
logFailure("Kubernetes API call failed: %s", err.Error())
logger.Failuref("Kubernetes API call failed: %s", err.Error())
return false
}
v, err := semver.ParseTolerant(ver.String())
if err != nil {
logFailure("Kubernetes version can't be determined")
logger.Failuref("Kubernetes version can't be determined")
return false
}
rng, _ := semver.ParseRange(version)
if !rng(v) {
logFailure("Kubernetes version must be %s", version)
logger.Failuref("Kubernetes version must be %s", version)
return false
}
logSuccess("Kubernetes %s %s", v.String(), version)
logger.Successf("Kubernetes %s %s", v.String(), version)
return true
}
@ -162,10 +162,10 @@ func componentsCheck() bool {
command := fmt.Sprintf("kubectl -n %s rollout status deployment %s --timeout=%s",
namespace, deployment, timeout.String())
if output, err := utils.execCommand(ctx, ModeCapture, command); err != nil {
logFailure("%s: %s", deployment, strings.TrimSuffix(output, "\n"))
logger.Failuref("%s: %s", deployment, strings.TrimSuffix(output, "\n"))
ok = false
} else {
logSuccess("%s is healthy", deployment)
logger.Successf("%s is healthy", deployment)
}
}
return ok

14
cmd/tk/create_kustomization.go
View File

@ -122,7 +122,7 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
}
if !export {
logGenerate("generating kustomization")
logger.Generatef("generating kustomization")
}
emptyAPIGroup := ""
@ -192,18 +192,18 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
return exportKs(kustomization)
}
logAction("applying kustomization")
logger.Actionf("applying kustomization")
if err := upsertKustomization(ctx, kubeClient, kustomization); err != nil {
return err
}
logWaiting("waiting for kustomization sync")
logger.Waitingf("waiting for kustomization sync")
if err := wait.PollImmediate(pollInterval, timeout,
isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
return err
}
logSuccess("kustomization %s is ready", name)
logger.Successf("kustomization %s is ready", name)
namespacedName := types.NamespacedName{
Namespace: namespace,
@ -215,7 +215,7 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
}
if kustomization.Status.LastAppliedRevision != "" {
logSuccess("applied revision %s", kustomization.Status.LastAppliedRevision)
logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
} else {
return fmt.Errorf("kustomization sync failed")
}
@ -236,7 +236,7 @@ func upsertKustomization(ctx context.Context, kubeClient client.Client, kustomiz
if err := kubeClient.Create(ctx, &kustomization); err != nil {
return err
} else {
logSuccess("kustomization created")
logger.Successf("kustomization created")
return nil
}
}
@ -248,7 +248,7 @@ func upsertKustomization(ctx context.Context, kubeClient client.Client, kustomiz
return err
}
logSuccess("kustomization updated")
logger.Successf("kustomization updated")
return nil
}

26
cmd/tk/create_source_git.go
View File

@ -166,7 +166,7 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
withAuth := false
// TODO(hidde): move all auth prep to separate func?
if u.Scheme == "ssh" {
logAction("generating deploy key pair")
logger.Actionf("generating deploy key pair")
pair, err := generateKeyPair(ctx)
if err != nil {
return err
@ -181,15 +181,15 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
return fmt.Errorf("aborting")
}
logAction("collecting preferred public key from SSH server")
logger.Actionf("collecting preferred public key from SSH server")
hostKey, err := scanHostKey(ctx, u)
if err != nil {
return err
}
logSuccess("collected public key from SSH server:")
logger.Successf("collected public key from SSH server:")
fmt.Printf("%s", hostKey)
logAction("applying secret with keys")
logger.Actionf("applying secret with keys")
secret := corev1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: name,
@ -206,7 +206,7 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
withAuth = true
} else if sourceGitUsername != "" && sourceGitPassword != "" {
logAction("applying secret with basic auth credentials")
logger.Actionf("applying secret with basic auth credentials")
secret := corev1.Secret{
ObjectMeta: metav1.ObjectMeta{
Name: name,
@ -224,10 +224,10 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
if withAuth {
logSuccess("authentication configured")
logger.Successf("authentication configured")
}
logGenerate("generating source")
logger.Generatef("generating source")
if withAuth {
gitRepository.Spec.SecretRef = &corev1.LocalObjectReference{
@ -235,18 +235,18 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
}
logAction("applying source")
logger.Actionf("applying source")
if err := upsertGitRepository(ctx, kubeClient, gitRepository); err != nil {
return err
}
logWaiting("waiting for git sync")
logger.Waitingf("waiting for git sync")
if err := wait.PollImmediate(pollInterval, timeout,
isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
return err
}
logSuccess("git sync completed")
logger.Successf("git sync completed")
namespacedName := types.NamespacedName{
Namespace: namespace,
@ -258,7 +258,7 @@ func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
if gitRepository.Status.Artifact != nil {
logSuccess("fetched revision: %s", gitRepository.Status.Artifact.Revision)
logger.Successf("fetched revision: %s", gitRepository.Status.Artifact.Revision)
} else {
return fmt.Errorf("git sync failed, artifact not found")
}
@ -336,7 +336,7 @@ func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepos
if err := kubeClient.Create(ctx, &gitRepository); err != nil {
return err
} else {
logSuccess("source created")
logger.Successf("source created")
return nil
}
}
@ -348,7 +348,7 @@ func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepos
return err
}
logSuccess("source updated")
logger.Successf("source updated")
return nil
}

6
cmd/tk/delete_kustomization.go
View File

@ -65,7 +65,7 @@ func deleteKsCmdRun(cmd *cobra.Command, args []string) error {
if !deleteSilent {
if !kustomization.Spec.Suspend {
logWaiting("This action will remove the Kubernetes objects previously applied by the %s kustomization!", name)
logger.Waitingf("This action will remove the Kubernetes objects previously applied by the %s kustomization!", name)
}
prompt := promptui.Prompt{
Label: "Are you sure you want to delete this kustomization",
@ -76,12 +76,12 @@ func deleteKsCmdRun(cmd *cobra.Command, args []string) error {
}
}
logAction("deleting kustomization %s in %s namespace", name, namespace)
logger.Actionf("deleting kustomization %s in %s namespace", name, namespace)
err = kubeClient.Delete(ctx, &kustomization)
if err != nil {
return err
}
logSuccess("kustomization deleted")
logger.Successf("kustomization deleted")
return nil
}

4
cmd/tk/delete_source_git.go
View File

@ -72,12 +72,12 @@ func deleteSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
}
logAction("deleting source %s in %s namespace", name, namespace)
logger.Actionf("deleting source %s in %s namespace", name, namespace)
err = kubeClient.Delete(ctx, &git)
if err != nil {
return err
}
logSuccess("source deleted")
logger.Successf("source deleted")
return nil
}

2
cmd/tk/export_kustomization.go
View File

@ -67,7 +67,7 @@ func exportKsCmdRun(cmd *cobra.Command, args []string) error {
}
if len(list.Items) == 0 {
logFailure("no kustomizations found in %s namespace", namespace)
logger.Failuref("no kustomizations found in %s namespace", namespace)
return nil
}

2
cmd/tk/export_source_git.go
View File

@ -67,7 +67,7 @@ func exportSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
if len(list.Items) == 0 {
logFailure("no source found in %s namespace", namespace)
logger.Failuref("no source found in %s namespace", namespace)
return nil
}

12
cmd/tk/get_kustomization.go
View File

@ -53,13 +53,13 @@ func getKsCmdRun(cmd *cobra.Command, args []string) error {
}
if len(list.Items) == 0 {
logFailure("no kustomizations found in %s namespace", namespace)
logger.Failuref("no kustomizations found in %s namespace", namespace)
return nil
}
for _, kustomization := range list.Items {
if kustomization.Spec.Suspend {
logSuccess("%s is suspended", kustomization.GetName())
logger.Successf("%s is suspended", kustomization.GetName())
continue
}
isInitialized := false
@ -67,19 +67,19 @@ func getKsCmdRun(cmd *cobra.Command, args []string) error {
if condition.Type == kustomizev1.ReadyCondition {
if condition.Status != corev1.ConditionFalse {
if kustomization.Status.LastAppliedRevision != "" {
logSuccess("%s last applied revision %s", kustomization.GetName(), kustomization.Status.LastAppliedRevision)
logger.Successf("%s last applied revision %s", kustomization.GetName(), kustomization.Status.LastAppliedRevision)
} else {
logSuccess("%s reconciling", kustomization.GetName())
logger.Successf("%s reconciling", kustomization.GetName())
}
} else {
logFailure("%s %s", kustomization.GetName(), condition.Message)
logger.Failuref("%s %s", kustomization.GetName(), condition.Message)
}
isInitialized = true
break
}
}
if !isInitialized {
logFailure("%s is not ready", kustomization.GetName())
logger.Failuref("%s is not ready", kustomization.GetName())
}
}
return nil

8
cmd/tk/get_source_git.go
View File

@ -52,7 +52,7 @@ func getSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
if len(list.Items) == 0 {
logFailure("no sources found in %s namespace", namespace)
logger.Failuref("no sources found in %s namespace", namespace)
return nil
}
@ -61,16 +61,16 @@ func getSourceGitCmdRun(cmd *cobra.Command, args []string) error {
for _, condition := range source.Status.Conditions {
if condition.Type == sourcev1.ReadyCondition {
if condition.Status != corev1.ConditionFalse {
logSuccess("%s last fetched revision: %s", source.GetName(), source.Status.Artifact.Revision)
logger.Successf("%s last fetched revision: %s", source.GetName(), source.Status.Artifact.Revision)
} else {
logFailure("%s %s", source.GetName(), condition.Message)
logger.Failuref("%s %s", source.GetName(), condition.Message)
}
isInitialized = true
break
}
}
if !isInitialized {
logFailure("%s is not ready", source.GetName())
logger.Failuref("%s is not ready", source.GetName())
}
}
return nil

16
cmd/tk/install.go
View File

@ -81,7 +81,7 @@ func installCmdRun(cmd *cobra.Command, args []string) error {
}
defer os.RemoveAll(tmpDir)
logGenerate("generating manifests")
logger.Generatef("generating manifests")
if kustomizePath == "" {
err = genInstallManifests(installVersion, namespace, components, tmpDir)
if err != nil {
@ -103,9 +103,9 @@ func installCmdRun(cmd *cobra.Command, args []string) error {
fmt.Print(yaml)
}
}
logSuccess("manifests build completed")
logger.Successf("manifests build completed")
logAction("installing components in %s namespace", namespace)
logger.Actionf("installing components in %s namespace", namespace)
applyOutput := ModeStderrOS
if verbose {
applyOutput = ModeOS
@ -121,24 +121,24 @@ func installCmdRun(cmd *cobra.Command, args []string) error {
}
if installDryRun {
logSuccess("install dry-run finished")
logger.Successf("install dry-run finished")
return nil
} else {
logSuccess("install completed")
logger.Successf("install completed")
}
logWaiting("verifying installation")
logger.Waitingf("verifying installation")
for _, deployment := range components {
command = fmt.Sprintf("kubectl -n %s rollout status deployment %s --timeout=%s",
namespace, deployment, timeout.String())
if _, err := utils.execCommand(ctx, applyOutput, command); err != nil {
return fmt.Errorf("install failed")
} else {
logSuccess("%s ready", deployment)
logger.Successf("%s ready", deployment)
}
}
logSuccess("install finished")
logger.Successf("install finished")
return nil
}

12
cmd/tk/log.go
View File

@ -18,22 +18,24 @@ package main
import "fmt"
func logAction(format string, a ...interface{}) {
type printLogger struct{}
func (l printLogger) Actionf(format string, a ...interface{}) {
fmt.Println(`►`, fmt.Sprintf(format, a...))
}
func logGenerate(format string, a ...interface{}) {
func (l printLogger) Generatef(format string, a ...interface{}) {
fmt.Println(`✚`, fmt.Sprintf(format, a...))
}
func logWaiting(format string, a ...interface{}) {
func (l printLogger) Waitingf(format string, a ...interface{}) {
fmt.Println(`◎`, fmt.Sprintf(format, a...))
}
func logSuccess(format string, a ...interface{}) {
func (l printLogger) Successf(format string, a ...interface{}) {
fmt.Println(`✔`, fmt.Sprintf(format, a...))
}
func logFailure(format string, a ...interface{}) {
func (l printLogger) Failuref(format string, a ...interface{}) {
fmt.Println(`✗`, fmt.Sprintf(format, a...))
}

7
cmd/tk/main.go
View File

@ -25,6 +25,8 @@ import (
"github.com/spf13/cobra"
"github.com/spf13/cobra/doc"
_ "k8s.io/client-go/plugin/pkg/client/auth"
tklog "github.com/fluxcd/toolkit/pkg/log"
)
var VERSION = "0.0.0-dev.0"
@ -98,7 +100,8 @@ var (
verbose bool
components []string
utils Utils
pollInterval = 2 * time.Second
pollInterval = 2 * time.Second
logger tklog.Logger = printLogger{}
)
func init() {
@ -118,7 +121,7 @@ func main() {
generateDocs()
kubeconfigFlag()
if err := rootCmd.Execute(); err != nil {
logFailure("%v", err)
logger.Failuref("%v", err)
os.Exit(1)
}
}

10
cmd/tk/resume_kustomization.go
View File

@ -66,20 +66,20 @@ func resumeKsCmdRun(cmd *cobra.Command, args []string) error {
return err
}
logAction("resuming kustomization %s in %s namespace", name, namespace)
logger.Actionf("resuming kustomization %s in %s namespace", name, namespace)
kustomization.Spec.Suspend = false
if err := kubeClient.Update(ctx, &kustomization); err != nil {
return err
}
logSuccess("kustomization resumed")
logger.Successf("kustomization resumed")
logWaiting("waiting for kustomization sync")
logger.Waitingf("waiting for kustomization sync")
if err := wait.PollImmediate(pollInterval, timeout,
isKustomizationResumed(ctx, kubeClient, name, namespace)); err != nil {
return err
}
logSuccess("kustomization sync completed")
logger.Successf("kustomization sync completed")
err = kubeClient.Get(ctx, namespacedName, &kustomization)
if err != nil {
@ -87,7 +87,7 @@ func resumeKsCmdRun(cmd *cobra.Command, args []string) error {
}
if kustomization.Status.LastAppliedRevision != "" {
logSuccess("applied revision %s", kustomization.Status.LastAppliedRevision)
logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
} else {
return fmt.Errorf("kustomization sync failed")
}

4
cmd/tk/suspend_kustomization.go
View File

@ -60,12 +60,12 @@ func suspendKsCmdRun(cmd *cobra.Command, args []string) error {
return err
}
logAction("suspending kustomization %s in %s namespace", name, namespace)
logger.Actionf("suspending kustomization %s in %s namespace", name, namespace)
kustomization.Spec.Suspend = true
if err := kubeClient.Update(ctx, &kustomization); err != nil {
return err
}
logSuccess("kustomization suspended")
logger.Successf("kustomization suspended")
return nil
}

10
cmd/tk/sync_kustomization.go
View File

@ -83,7 +83,7 @@ func syncKsCmdRun(cmd *cobra.Command, args []string) error {
return err
}
} else {
logAction("annotating kustomization %s in %s namespace", name, namespace)
logger.Actionf("annotating kustomization %s in %s namespace", name, namespace)
if kustomization.Annotations == nil {
kustomization.Annotations = map[string]string{
kustomizev1.SyncAtAnnotation: time.Now().String(),
@ -94,16 +94,16 @@ func syncKsCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &kustomization); err != nil {
return err
}
logSuccess("kustomization annotated")
logger.Successf("kustomization annotated")
}
logWaiting("waiting for kustomization sync")
logger.Waitingf("waiting for kustomization sync")
if err := wait.PollImmediate(pollInterval, timeout,
isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
return err
}
logSuccess("kustomization sync completed")
logger.Successf("kustomization sync completed")
err = kubeClient.Get(ctx, namespacedName, &kustomization)
if err != nil {
@ -111,7 +111,7 @@ func syncKsCmdRun(cmd *cobra.Command, args []string) error {
}
if kustomization.Status.LastAppliedRevision != "" {
logSuccess("applied revision %s", kustomization.Status.LastAppliedRevision)
logger.Successf("applied revision %s", kustomization.Status.LastAppliedRevision)
} else {
return fmt.Errorf("kustomization sync failed")
}

10
cmd/tk/sync_source_git.go
View File

@ -59,7 +59,7 @@ func syncSourceGitCmdRun(cmd *cobra.Command, args []string) error {
Name: name,
}
logAction("annotating source %s in %s namespace", name, namespace)
logger.Actionf("annotating source %s in %s namespace", name, namespace)
var gitRepository sourcev1.GitRepository
err = kubeClient.Get(ctx, namespacedName, &gitRepository)
if err != nil {
@ -76,15 +76,15 @@ func syncSourceGitCmdRun(cmd *cobra.Command, args []string) error {
if err := kubeClient.Update(ctx, &gitRepository); err != nil {
return err
}
logSuccess("source annotated")
logger.Successf("source annotated")
logWaiting("waiting for git sync")
logger.Waitingf("waiting for git sync")
if err := wait.PollImmediate(pollInterval, timeout,
isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
return err
}
logSuccess("git sync completed")
logger.Successf("git sync completed")
err = kubeClient.Get(ctx, namespacedName, &gitRepository)
if err != nil {
@ -92,7 +92,7 @@ func syncSourceGitCmdRun(cmd *cobra.Command, args []string) error {
}
if gitRepository.Status.Artifact != nil {
logSuccess("fetched revision: %s", gitRepository.Status.Artifact.Revision)
logger.Successf("fetched revision %s", gitRepository.Status.Artifact.Revision)
} else {
return fmt.Errorf("git sync failed, artifact not found")
}

8
cmd/tk/uninstall.go
View File

@ -76,7 +76,7 @@ func uninstallCmdRun(cmd *cobra.Command, args []string) error {
}
if uninstallKustomizations {
logAction("uninstalling kustomizations")
logger.Actionf("uninstalling kustomizations")
command := fmt.Sprintf("kubectl -n %s delete kustomizations --all --timeout=%s %s",
namespace, timeout.String(), dryRun)
if _, err := utils.execCommand(ctx, ModeOS, command); err != nil {
@ -85,7 +85,7 @@ func uninstallCmdRun(cmd *cobra.Command, args []string) error {
// TODO: use the kustomizations snapshots to create a list of objects
// that are subject to deletion and wait for all of them to be terminated
logWaiting("waiting on GC")
logger.Waitingf("waiting on GC")
time.Sleep(30 * time.Second)
}
@ -94,13 +94,13 @@ func uninstallCmdRun(cmd *cobra.Command, args []string) error {
kinds += ",crds"
}
logAction("uninstalling components")
logger.Actionf("uninstalling components")
command := fmt.Sprintf("kubectl delete %s -l app.kubernetes.io/instance=%s --timeout=%s %s",
kinds, namespace, timeout.String(), dryRun)
if _, err := utils.execCommand(ctx, ModeOS, command); err != nil {
return fmt.Errorf("uninstall failed")
}
logSuccess("uninstall finished")
logger.Successf("uninstall finished")
return nil
}

29
pkg/log/log.go Normal file
View File

@ -0,0 +1,29 @@
/*
Copyright 2020 The Flux CD contributors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package log
type Logger interface {
// Actionf logs a formatted action message.
Actionf(format string, a ...interface{})
// Generatef logs a formatted generate message.
Generatef(format string, a ...interface{})
// Waitingf logs a formatted waiting message.
Waitingf(format string, a ...interface{})
// Waitingf logs a formatted success message.
Successf(format string, a ...interface{})
// Failuref logs a formatted failure message.
Failuref(format string, a ...interface{})
}