Merge pull request #10 from fluxcd/create-source-git

Implement sync commands

.github/workflows/e2e.yaml

@@ -37,21 +37,40 @@ jobs:
           fi
       - name: Build
         run: sudo go build -o ./bin/tk ./cmd/tk
-      - name: Run check e2e tests
+      - name: tk check --pre
         run: |
-          ./bin/tk check
-      - name: Run install version e2e tests
+          ./bin/tk check --pre
+      - name: tk install --version
         run: |
           ./bin/tk install --version=master --namespace=test --verbose
-      - name: Run uninstall e2e tests
+      - name: tk uninstall
         run: |
           ./bin/tk uninstall --namespace=test --crds --silent
-      - name: Run dev install e2e tests
+      - name: tk install --manifests
         run: |
           ./bin/tk install --manifests ./manifests/install/
-      - name: Run create source e2e tests
+      - name: tk create source git
         run: |
-          ./bin/tk create source podinfo --git-url https://github.com/stefanprodan/podinfo-deploy  --git-semver=">=0.0.1-rc.1 <0.1.0"
+          ./bin/tk create source git podinfo \
+            --url https://github.com/stefanprodan/podinfo  \
+            --tag-semver=">=3.2.3"
+      - name: tk create kustomization
+        run: |
+          ./bin/tk create kustomization podinfo \
+            --source=podinfo \
+            --path="./deploy/overlays/dev" \
+            --prune="env=dev,instance=webapp" \
+            --interval=5m \
+            --validate=client \
+            --health-check="Deployment/frontend.dev" \
+            --health-check="Deployment/backend.dev" \
+            --health-check-timeout=3m
+      - name: tk sync kustomization --with-source
+        run: |
+          ./bin/tk sync kustomization podinfo --with-source
+      - name: tk check
+        run: |
+          ./bin/tk check
       - name: Debug failure
         if: failure()
         run: |

cmd/tk/check.go

@@ -69,6 +69,7 @@ func runCheckCmd(cmd *cobra.Command, args []string) error {
 		return nil
 	}
 
+	logAction("checking controllers")
 	if !componentsCheck() {
 		checkFailed = true
 	}
@@ -202,14 +203,16 @@ func componentsCheck() bool {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
+	ok := true
 	for _, deployment := range components {
 		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"))
+			ok = false
 		} else {
 			logSuccess("%s is healthy", deployment)
 		}
 	}
-	return true
+	return ok
 }

cmd/tk/create_kustomization.go

@@ -19,6 +19,7 @@ import (
 
 var createKsCmd = &cobra.Command{
 	Use:     "kustomization [name]",
+	Aliases: []string{"ks"},
 	Short:   "Create or update a kustomization resource",
 	Long: `
 The kustomization source command generates a kustomization.kustomize.fluxcd.io resource for a given GitRepository source.
@@ -95,7 +96,7 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	logAction("generating %s kustomization", name)
+	logGenerate("generating kustomization")
 
 	emptyAPIGroup := ""
 	kustomization := kustomizev1.Kustomization{
@@ -154,12 +155,13 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
 		}
 	}
 
+	logAction("applying kustomization")
 	if err := upsertKustomization(ctx, kubeClient, kustomization); err != nil {
 		return err
 	}
 
-	logAction("waiting for kustomization sync")
-	if err := wait.PollImmediate(2*time.Second, timeout,
+	logWaiting("waiting for kustomization sync")
+	if err := wait.PollImmediate(pollInterval, timeout,
 		isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
 		return err
 	}

cmd/tk/create_source.go

@@ -1,287 +1,14 @@
 package main
 
 import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"net/url"
-	"os"
-	"strings"
-	"time"
-
-	sourcev1 "github.com/fluxcd/source-controller/api/v1alpha1"
-	"github.com/manifoldco/promptui"
 	"github.com/spf13/cobra"
-	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 var createSourceCmd = &cobra.Command{
-	Use:   "source [name]",
-	Short: "Create or update a source resource",
-	Long: `
-The create source command generates a source.fluxcd.io resource and waits for it to sync.
-For Git over SSH, host and SSH keys are automatically generated and stored in a Kubernetes secret.
-For private Git repositories, the basic authentication credentials are stored in a Kubernetes secret.`,
-	Example: `  # Create a source from a public Git repository master branch
-  create source podinfo \
-    --git-url=https://github.com/stefanprodan/podinfo \
-    --git-branch=master
-
-  # Create a source from a Git repository pinned to specific git tag
-  create source podinfo \
-    --git-url=https://github.com/stefanprodan/podinfo \
-    --git-tag="3.2.3"
-
-  # Create a source from a public Git repository tag that matches a semver range
-  create source podinfo \
-    --git-url=https://github.com/stefanprodan/podinfo \
-    --git-semver=">=3.2.0 <3.3.0"
-
-  #  Create a source from a Git repository using SSH authentication
-  create source podinfo \
-    --git-url=ssh://git@github.com/stefanprodan/podinfo \
-    --git-branch=master
-
-  # Create a source from a Git repository using basic authentication
-  create source podinfo \
-    --git-url=https://github.com/stefanprodan/podinfo \
-    --username=username \
-    --password=password
-`,
-	RunE: createSourceCmdRun,
+	Use:   "source",
+	Short: "Create source commands",
 }
 
-var (
-	sourceGitURL    string
-	sourceGitBranch string
-	sourceGitTag    string
-	sourceGitSemver string
-	sourceUsername  string
-	sourcePassword  string
-)
-
 func init() {
-	createSourceCmd.Flags().StringVar(&sourceGitURL, "git-url", "", "git address, e.g. ssh://git@host/org/repository")
-	createSourceCmd.Flags().StringVar(&sourceGitBranch, "git-branch", "master", "git branch")
-	createSourceCmd.Flags().StringVar(&sourceGitTag, "git-tag", "", "git tag")
-	createSourceCmd.Flags().StringVar(&sourceGitSemver, "git-semver", "", "git tag semver range")
-	createSourceCmd.Flags().StringVarP(&sourceUsername, "username", "u", "", "basic authentication username")
-	createSourceCmd.Flags().StringVarP(&sourcePassword, "password", "p", "", "basic authentication password")
-
 	createCmd.AddCommand(createSourceCmd)
 }
-
-func createSourceCmdRun(cmd *cobra.Command, args []string) error {
-	if len(args) < 1 {
-		return fmt.Errorf("source name is required")
-	}
-	name := args[0]
-
-	if sourceGitURL == "" {
-		return fmt.Errorf("git-url is required")
-	}
-
-	tmpDir, err := ioutil.TempDir("", name)
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(tmpDir)
-
-	u, err := url.Parse(sourceGitURL)
-	if err != nil {
-		return fmt.Errorf("git URL parse failed: %w", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	withAuth := false
-	if strings.HasPrefix(sourceGitURL, "ssh") {
-		if err := generateSSH(ctx, name, u.Host, tmpDir); err != nil {
-			return err
-		}
-		withAuth = true
-	} else if sourceUsername != "" && sourcePassword != "" {
-		if err := generateBasicAuth(ctx, name); err != nil {
-			return err
-		}
-		withAuth = true
-	}
-
-	logAction("generating source %s in %s namespace", name, namespace)
-
-	gitRepository := sourcev1.GitRepository{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      name,
-			Namespace: namespace,
-		},
-		Spec: sourcev1.GitRepositorySpec{
-			URL: sourceGitURL,
-			Interval: metav1.Duration{
-				Duration: interval,
-			},
-			Reference: &sourcev1.GitRepositoryRef{},
-		},
-	}
-
-	if withAuth {
-		gitRepository.Spec.SecretRef = &corev1.LocalObjectReference{
-			Name: name,
-		}
-	}
-
-	if sourceGitSemver != "" {
-		gitRepository.Spec.Reference.SemVer = sourceGitSemver
-	} else if sourceGitTag != "" {
-		gitRepository.Spec.Reference.Tag = sourceGitTag
-	} else {
-		gitRepository.Spec.Reference.Branch = sourceGitBranch
-	}
-
-	kubeClient, err := utils.kubeClient(kubeconfig)
-	if err != nil {
-		return err
-	}
-
-	if err := upsertGitRepository(ctx, kubeClient, gitRepository); err != nil {
-		return err
-	}
-
-	logAction("waiting for source sync")
-	if err := wait.PollImmediate(2*time.Second, timeout,
-		isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
-		return err
-	}
-
-	logSuccess("source %s is ready", name)
-
-	namespacedName := types.NamespacedName{
-		Namespace: namespace,
-		Name:      name,
-	}
-	err = kubeClient.Get(ctx, namespacedName, &gitRepository)
-	if err != nil {
-		return fmt.Errorf("source sync failed: %w", err)
-	}
-
-	if gitRepository.Status.Artifact != nil {
-		logSuccess("fetched revision %s", gitRepository.Status.Artifact.Revision)
-	} else {
-		return fmt.Errorf("source sync failed, artifact not found")
-	}
-
-	return nil
-}
-
-func generateBasicAuth(ctx context.Context, name string) error {
-	logAction("saving credentials")
-	credentials := fmt.Sprintf("--from-literal=username='%s' --from-literal=password='%s'",
-		sourceUsername, sourcePassword)
-	secret := fmt.Sprintf("kubectl -n %s create secret generic %s %s --dry-run=client -oyaml | kubectl apply -f-",
-		namespace, name, credentials)
-	if _, err := utils.execCommand(ctx, ModeOS, secret); err != nil {
-		return fmt.Errorf("kubectl create secret failed")
-	}
-	return nil
-}
-
-func generateSSH(ctx context.Context, name, host, tmpDir string) error {
-	logAction("generating host key for %s", host)
-
-	command := fmt.Sprintf("ssh-keyscan %s > %s/known_hosts", host, tmpDir)
-	if _, err := utils.execCommand(ctx, ModeStderrOS, command); err != nil {
-		return fmt.Errorf("ssh-keyscan failed")
-	}
-
-	logAction("generating deploy key")
-
-	command = fmt.Sprintf("ssh-keygen -b 2048 -t rsa -f %s/identity -q -N \"\"", tmpDir)
-	if _, err := utils.execCommand(ctx, ModeStderrOS, command); err != nil {
-		return fmt.Errorf("ssh-keygen failed")
-	}
-
-	command = fmt.Sprintf("cat %s/identity.pub", tmpDir)
-	if deployKey, err := utils.execCommand(ctx, ModeCapture, command); err != nil {
-		return fmt.Errorf("unable to read identity.pub: %w", err)
-	} else {
-		fmt.Print(deployKey)
-	}
-
-	prompt := promptui.Prompt{
-		Label:     "Have you added the deploy key to your repository",
-		IsConfirm: true,
-	}
-	if _, err := prompt.Run(); err != nil {
-		return fmt.Errorf("aborting")
-	}
-
-	logAction("saving deploy key")
-	files := fmt.Sprintf("--from-file=%s/identity --from-file=%s/identity.pub --from-file=%s/known_hosts",
-		tmpDir, tmpDir, tmpDir)
-	secret := fmt.Sprintf("kubectl -n %s create secret generic %s %s --dry-run=client -oyaml | kubectl apply -f-",
-		namespace, name, files)
-	if _, err := utils.execCommand(ctx, ModeOS, secret); err != nil {
-		return fmt.Errorf("create secret failed")
-	}
-	return nil
-}
-
-func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepository sourcev1.GitRepository) error {
-	namespacedName := types.NamespacedName{
-		Namespace: gitRepository.GetNamespace(),
-		Name:      gitRepository.GetName(),
-	}
-
-	var existing sourcev1.GitRepository
-	err := kubeClient.Get(ctx, namespacedName, &existing)
-	if err != nil {
-		if errors.IsNotFound(err) {
-			if err := kubeClient.Create(ctx, &gitRepository); err != nil {
-				return err
-			} else {
-				logSuccess("source created")
-				return nil
-			}
-		}
-		return err
-	}
-
-	existing.Spec = gitRepository.Spec
-	if err := kubeClient.Update(ctx, &existing); err != nil {
-		return err
-	}
-
-	logSuccess("source updated")
-	return nil
-}
-
-func isGitRepositoryReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
-	return func() (bool, error) {
-		var gitRepository sourcev1.GitRepository
-		namespacedName := types.NamespacedName{
-			Namespace: namespace,
-			Name:      name,
-		}
-
-		err := kubeClient.Get(ctx, namespacedName, &gitRepository)
-		if err != nil {
-			return false, err
-		}
-
-		for _, condition := range gitRepository.Status.Conditions {
-			if condition.Type == sourcev1.ReadyCondition {
-				if condition.Status == corev1.ConditionTrue {
-					return true, nil
-				} else if condition.Status == corev1.ConditionFalse {
-					return false, fmt.Errorf(condition.Message)
-				}
-			}
-		}
-		return false, nil
-	}
-}

cmd/tk/create_source_git.go

@@ -0,0 +1,290 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	sourcev1 "github.com/fluxcd/source-controller/api/v1alpha1"
+	"github.com/manifoldco/promptui"
+	"github.com/spf13/cobra"
+	"io/ioutil"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"net/url"
+	"os"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"strings"
+)
+
+var createSourceGitCmd = &cobra.Command{
+	Use:   "git [name]",
+	Short: "Create or update a git source",
+	Long: `
+The create source command generates a GitRepository resource and waits for it to sync.
+For Git over SSH, host and SSH keys are automatically generated and stored in a Kubernetes secret.
+For private Git repositories, the basic authentication credentials are stored in a Kubernetes secret.`,
+	Example: `  # Create a source from a public Git repository master branch
+  create source git podinfo \
+    --url=https://github.com/stefanprodan/podinfo \
+    --branch=master
+
+  # Create a source from a Git repository pinned to specific git tag
+  create source git podinfo \
+    --url=https://github.com/stefanprodan/podinfo \
+    --tag="3.2.3"
+
+  # Create a source from a public Git repository tag that matches a semver range
+  create source git podinfo \
+    --url=https://github.com/stefanprodan/podinfo \
+    --tag-semver=">=3.2.0 <3.3.0"
+
+  #  Create a source from a Git repository using SSH authentication
+  create source git podinfo \
+    --url=ssh://git@github.com/stefanprodan/podinfo \
+    --branch=master
+
+  # Create a source from a Git repository using basic authentication
+  create source git podinfo \
+    --url=https://github.com/stefanprodan/podinfo \
+    --username=username \
+    --password=password
+`,
+	RunE: createSourceGitCmdRun,
+}
+
+var (
+	sourceGitURL      string
+	sourceGitBranch   string
+	sourceGitTag      string
+	sourceGitSemver   string
+	sourceGitUsername string
+	sourceGitPassword string
+)
+
+func init() {
+	createSourceGitCmd.Flags().StringVar(&sourceGitURL, "url", "", "git address, e.g. ssh://git@host/org/repository")
+	createSourceGitCmd.Flags().StringVar(&sourceGitBranch, "branch", "master", "git branch")
+	createSourceGitCmd.Flags().StringVar(&sourceGitTag, "tag", "", "git tag")
+	createSourceGitCmd.Flags().StringVar(&sourceGitSemver, "tag-semver", "", "git tag semver range")
+	createSourceGitCmd.Flags().StringVarP(&sourceGitUsername, "username", "u", "", "basic authentication username")
+	createSourceGitCmd.Flags().StringVarP(&sourceGitPassword, "password", "p", "", "basic authentication password")
+
+	createSourceCmd.AddCommand(createSourceGitCmd)
+}
+
+func createSourceGitCmdRun(cmd *cobra.Command, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("source name is required")
+	}
+	name := args[0]
+
+	if sourceGitURL == "" {
+		return fmt.Errorf("git-url is required")
+	}
+
+	tmpDir, err := ioutil.TempDir("", name)
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(tmpDir)
+
+	u, err := url.Parse(sourceGitURL)
+	if err != nil {
+		return fmt.Errorf("git URL parse failed: %w", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	withAuth := false
+	if strings.HasPrefix(sourceGitURL, "ssh") {
+		if err := generateSSH(ctx, name, u.Host, tmpDir); err != nil {
+			return err
+		}
+		withAuth = true
+	} else if sourceGitUsername != "" && sourceGitPassword != "" {
+		if err := generateBasicAuth(ctx, name); err != nil {
+			return err
+		}
+		withAuth = true
+	}
+
+	if withAuth {
+		logSuccess("authentication configured")
+	}
+
+	logGenerate("generating source")
+
+	gitRepository := sourcev1.GitRepository{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: sourcev1.GitRepositorySpec{
+			URL: sourceGitURL,
+			Interval: metav1.Duration{
+				Duration: interval,
+			},
+			Reference: &sourcev1.GitRepositoryRef{},
+		},
+	}
+
+	if withAuth {
+		gitRepository.Spec.SecretRef = &corev1.LocalObjectReference{
+			Name: name,
+		}
+	}
+
+	if sourceGitSemver != "" {
+		gitRepository.Spec.Reference.SemVer = sourceGitSemver
+	} else if sourceGitTag != "" {
+		gitRepository.Spec.Reference.Tag = sourceGitTag
+	} else {
+		gitRepository.Spec.Reference.Branch = sourceGitBranch
+	}
+
+	kubeClient, err := utils.kubeClient(kubeconfig)
+	if err != nil {
+		return err
+	}
+
+	logAction("applying source")
+	if err := upsertGitRepository(ctx, kubeClient, gitRepository); err != nil {
+		return err
+	}
+
+	logWaiting("waiting for git sync")
+	if err := wait.PollImmediate(pollInterval, timeout,
+		isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+		return err
+	}
+
+	logSuccess("git sync completed")
+
+	namespacedName := types.NamespacedName{
+		Namespace: namespace,
+		Name:      name,
+	}
+	err = kubeClient.Get(ctx, namespacedName, &gitRepository)
+	if err != nil {
+		return fmt.Errorf("git sync failed: %w", err)
+	}
+
+	if gitRepository.Status.Artifact != nil {
+		logSuccess("fetched revision %s", gitRepository.Status.Artifact.Revision)
+	} else {
+		return fmt.Errorf("git sync failed, artifact not found")
+	}
+
+	return nil
+}
+
+func generateBasicAuth(ctx context.Context, name string) error {
+	logAction("saving credentials")
+	credentials := fmt.Sprintf("--from-literal=username='%s' --from-literal=password='%s'",
+		sourceGitUsername, sourceGitPassword)
+	secret := fmt.Sprintf("kubectl -n %s create secret generic %s %s --dry-run=client -oyaml | kubectl apply -f-",
+		namespace, name, credentials)
+	if _, err := utils.execCommand(ctx, ModeOS, secret); err != nil {
+		return fmt.Errorf("kubectl create secret failed")
+	}
+	return nil
+}
+
+func generateSSH(ctx context.Context, name, host, tmpDir string) error {
+	logGenerate("generating host key for %s", host)
+
+	command := fmt.Sprintf("ssh-keyscan %s > %s/known_hosts", host, tmpDir)
+	if _, err := utils.execCommand(ctx, ModeStderrOS, command); err != nil {
+		return fmt.Errorf("ssh-keyscan failed")
+	}
+
+	logGenerate("generating deploy key")
+
+	command = fmt.Sprintf("ssh-keygen -b 2048 -t rsa -f %s/identity -q -N \"\"", tmpDir)
+	if _, err := utils.execCommand(ctx, ModeStderrOS, command); err != nil {
+		return fmt.Errorf("ssh-keygen failed")
+	}
+
+	command = fmt.Sprintf("cat %s/identity.pub", tmpDir)
+	if deployKey, err := utils.execCommand(ctx, ModeCapture, command); err != nil {
+		return fmt.Errorf("unable to read identity.pub: %w", err)
+	} else {
+		fmt.Print(deployKey)
+	}
+
+	prompt := promptui.Prompt{
+		Label:     "Have you added the deploy key to your repository",
+		IsConfirm: true,
+	}
+	if _, err := prompt.Run(); err != nil {
+		return fmt.Errorf("aborting")
+	}
+
+	logAction("saving keys")
+	files := fmt.Sprintf("--from-file=%s/identity --from-file=%s/identity.pub --from-file=%s/known_hosts",
+		tmpDir, tmpDir, tmpDir)
+	secret := fmt.Sprintf("kubectl -n %s create secret generic %s %s --dry-run=client -oyaml | kubectl apply -f-",
+		namespace, name, files)
+	if _, err := utils.execCommand(ctx, ModeOS, secret); err != nil {
+		return fmt.Errorf("create secret failed")
+	}
+	return nil
+}
+
+func upsertGitRepository(ctx context.Context, kubeClient client.Client, gitRepository sourcev1.GitRepository) error {
+	namespacedName := types.NamespacedName{
+		Namespace: gitRepository.GetNamespace(),
+		Name:      gitRepository.GetName(),
+	}
+
+	var existing sourcev1.GitRepository
+	err := kubeClient.Get(ctx, namespacedName, &existing)
+	if err != nil {
+		if errors.IsNotFound(err) {
+			if err := kubeClient.Create(ctx, &gitRepository); err != nil {
+				return err
+			} else {
+				logSuccess("source created")
+				return nil
+			}
+		}
+		return err
+	}
+
+	existing.Spec = gitRepository.Spec
+	if err := kubeClient.Update(ctx, &existing); err != nil {
+		return err
+	}
+
+	logSuccess("source updated")
+	return nil
+}
+
+func isGitRepositoryReady(ctx context.Context, kubeClient client.Client, name, namespace string) wait.ConditionFunc {
+	return func() (bool, error) {
+		var gitRepository sourcev1.GitRepository
+		namespacedName := types.NamespacedName{
+			Namespace: namespace,
+			Name:      name,
+		}
+
+		err := kubeClient.Get(ctx, namespacedName, &gitRepository)
+		if err != nil {
+			return false, err
+		}
+
+		for _, condition := range gitRepository.Status.Conditions {
+			if condition.Type == sourcev1.ReadyCondition {
+				if condition.Status == corev1.ConditionTrue {
+					return true, nil
+				} else if condition.Status == corev1.ConditionFalse {
+					return false, fmt.Errorf(condition.Message)
+				}
+			}
+		}
+		return false, nil
+	}
+}

cmd/tk/install.go

@@ -63,7 +63,7 @@ func installCmdRun(cmd *cobra.Command, args []string) error {
 	}
 	defer os.RemoveAll(tmpDir)
 
-	logAction("generating install manifests")
+	logGenerate("generating manifests")
 	if kustomizePath == "" {
 		err = genInstallManifests(installVersion, namespace, components, tmpDir)
 		if err != nil {
@@ -86,7 +86,7 @@ func installCmdRun(cmd *cobra.Command, args []string) error {
 			fmt.Print(yaml)
 		}
 	}
-	logSuccess("build completed")
+	logSuccess("manifests build completed")
 
 	logAction("installing components in %s namespace", namespace)
 	applyOutput := ModeStderrOS
@@ -110,7 +110,7 @@ func installCmdRun(cmd *cobra.Command, args []string) error {
 		logSuccess("install completed")
 	}
 
-	logAction("verifying installation")
+	logWaiting("verifying installation")
 	for _, deployment := range components {
 		command = fmt.Sprintf("kubectl -n %s rollout status deployment %s --timeout=%s",
 			namespace, deployment, timeout.String())

cmd/tk/log.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+func logAction(format string, a ...interface{}) {
+	fmt.Println(`►`, fmt.Sprintf(format, a...))
+}
+
+func logGenerate(format string, a ...interface{}) {
+	fmt.Println(`✚`, fmt.Sprintf(format, a...))
+}
+
+func logWaiting(format string, a ...interface{}) {
+	fmt.Println(`◎`, fmt.Sprintf(format, a...))
+}
+
+func logSuccess(format string, a ...interface{}) {
+	fmt.Println(`✔`, fmt.Sprintf(format, a...))
+}
+
+func logFailure(format string, a ...interface{}) {
+	fmt.Println(`✗`, fmt.Sprintf(format, a...))
+}

cmd/tk/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"log"
 	"os"
 	"path/filepath"
@@ -20,7 +19,7 @@ var rootCmd = &cobra.Command{
 	SilenceUsage:  true,
 	SilenceErrors: true,
 	Short:         "Command line utility for assembling Kubernetes CD pipelines",
-	Long:          `Command line utility for assembling Kubernetes CD pipelines.`,
+	Long:          `Command line utility for assembling Kubernetes CD pipelines the GitOps way.`,
 	Example: `  # Check prerequisites 
   tk check --pre
 
@@ -28,10 +27,10 @@ var rootCmd = &cobra.Command{
   tk install --version=master
 
   # Create a source from a public Git repository
-  tk create source webapp \
-    --git-url=https://github.com/stefanprodan/podinfo \
-    --git-branch=master \
-    --interval=5m
+  tk create source git webapp \
+    --url=https://github.com/stefanprodan/podinfo \
+    --branch=master \
+    --interval=3m
 
   # Create a kustomization for deploying a series of microservices
   tk create kustomization webapp \
@@ -44,6 +43,9 @@ var rootCmd = &cobra.Command{
     --health-check="Deployment/backend.webapp" \
     --health-check="Deployment/frontend.webapp" \
     --health-check-timeout=2m
+
+  # Trigger a git sync and apply changes if any
+  sync kustomization webapp --with-source
 `,
 }
 
@@ -54,6 +56,7 @@ var (
 	verbose      bool
 	components   []string
 	utils        Utils
+	pollInterval = 2 * time.Second
 )
 
 func init() {
@@ -78,23 +81,14 @@ func main() {
 	}
 }
 
-func homeDir() string {
-	if h := os.Getenv("HOME"); h != "" {
-		return h
+func kubeconfigFlag() {
+	if home := homeDir(); home != "" {
+		rootCmd.PersistentFlags().StringVarP(&kubeconfig, "kubeconfig", "", filepath.Join(home, ".kube", "config"),
+			"path to the kubeconfig file")
+	} else {
+		rootCmd.PersistentFlags().StringVarP(&kubeconfig, "kubeconfig", "", "",
+			"absolute path to the kubeconfig file")
 	}
-	return os.Getenv("USERPROFILE") // windows
-}
-
-func logAction(format string, a ...interface{}) {
-	fmt.Println(`✚`, fmt.Sprintf(format, a...))
-}
-
-func logSuccess(format string, a ...interface{}) {
-	fmt.Println(`✔`, fmt.Sprintf(format, a...))
-}
-
-func logFailure(format string, a ...interface{}) {
-	fmt.Println(`✗`, fmt.Sprintf(format, a...))
 }
 
 func generateDocs() {
@@ -110,12 +104,9 @@ func generateDocs() {
 	}
 }
 
-func kubeconfigFlag() {
-	if home := homeDir(); home != "" {
-		rootCmd.PersistentFlags().StringVarP(&kubeconfig, "kubeconfig", "", filepath.Join(home, ".kube", "config"),
-			"path to the kubeconfig file")
-	} else {
-		rootCmd.PersistentFlags().StringVarP(&kubeconfig, "kubeconfig", "", "",
-			"absolute path to the kubeconfig file")
+func homeDir() string {
+	if h := os.Getenv("HOME"); h != "" {
+		return h
 	}
+	return os.Getenv("USERPROFILE") // windows
 }

cmd/tk/sync.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var syncCmd = &cobra.Command{
+	Use:   "sync",
+	Short: "Synchronize commands",
+}
+
+func init() {
+	rootCmd.AddCommand(syncCmd)
+}

cmd/tk/sync_kustomization.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	kustomizev1 "github.com/fluxcd/kustomize-controller/api/v1alpha1"
+	"github.com/spf13/cobra"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+)
+
+var syncKsCmd = &cobra.Command{
+	Use:     "kustomization [name]",
+	Aliases: []string{"ks"},
+	Short:   "Synchronize kustomization",
+	Long: `
+The sync kustomization command triggers a reconciliation of a Kustomization resource and waits for it to finish.`,
+	Example: `  # Trigger a kustomization apply outside of the reconciliation interval
+  sync kustomization podinfo
+
+  # Trigger a git sync of the kustomization source and apply changes
+  sync kustomization podinfo --with-source
+`,
+	RunE: syncKsCmdRun,
+}
+
+var (
+	syncKsWithSource bool
+)
+
+func init() {
+	syncKsCmd.Flags().BoolVar(&syncKsWithSource, "with-source", false, "synchronize kustomization source")
+
+	syncCmd.AddCommand(syncKsCmd)
+}
+
+func syncKsCmdRun(cmd *cobra.Command, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("kustomization name is required")
+	}
+	name := args[0]
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	kubeClient, err := utils.kubeClient(kubeconfig)
+	if err != nil {
+		return err
+	}
+
+	namespacedName := types.NamespacedName{
+		Namespace: namespace,
+		Name:      name,
+	}
+
+	var kustomization kustomizev1.Kustomization
+	err = kubeClient.Get(ctx, namespacedName, &kustomization)
+	if err != nil {
+		return err
+	}
+
+	if syncKsWithSource {
+		err := syncSourceGitCmdRun(nil, []string{kustomization.Spec.SourceRef.Name})
+		if err != nil {
+			return err
+		}
+	} else {
+		logAction("annotating kustomization %s in %s namespace", name, namespace)
+		if kustomization.Annotations == nil {
+			kustomization.Annotations = map[string]string{
+				kustomizev1.SyncAtAnnotation: time.Now().String(),
+			}
+		} else {
+			kustomization.Annotations[kustomizev1.SyncAtAnnotation] = time.Now().String()
+		}
+		if err := kubeClient.Update(ctx, &kustomization); err != nil {
+			return err
+		}
+		logSuccess("kustomization annotated")
+	}
+
+	logWaiting("waiting for kustomization sync")
+	if err := wait.PollImmediate(pollInterval, timeout,
+		isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
+		return err
+	}
+
+	logSuccess("kustomization sync completed")
+
+	err = kubeClient.Get(ctx, namespacedName, &kustomization)
+	if err != nil {
+		return err
+	}
+
+	err = kubeClient.Get(ctx, namespacedName, &kustomization)
+	if err != nil {
+		return err
+	}
+
+	if kustomization.Status.LastAppliedRevision != "" {
+		logSuccess("applied revision %s", kustomization.Status.LastAppliedRevision)
+	} else {
+		return fmt.Errorf("kustomization sync failed")
+	}
+	return nil
+}

cmd/tk/sync_source.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var syncSourceCmd = &cobra.Command{
+	Use:   "source",
+	Short: "Synchronize source commands",
+}
+
+func init() {
+	syncCmd.AddCommand(syncSourceCmd)
+}

cmd/tk/sync_source_git.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	sourcev1 "github.com/fluxcd/source-controller/api/v1alpha1"
+	"github.com/spf13/cobra"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"time"
+)
+
+var syncSourceGitCmd = &cobra.Command{
+	Use:   "git [name]",
+	Short: "Synchronize git source",
+	Long: `
+The sync source command triggers a reconciliation of a GitRepository resource and waits for it to finish.`,
+	Example: `  # Trigger a git pull for an existing source
+  sync source git podinfo
+`,
+	RunE: syncSourceGitCmdRun,
+}
+
+func init() {
+	syncSourceCmd.AddCommand(syncSourceGitCmd)
+}
+
+func syncSourceGitCmdRun(cmd *cobra.Command, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("source name is required")
+	}
+	name := args[0]
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	kubeClient, err := utils.kubeClient(kubeconfig)
+	if err != nil {
+		return err
+	}
+
+	namespacedName := types.NamespacedName{
+		Namespace: namespace,
+		Name:      name,
+	}
+
+	logAction("annotating source %s in %s namespace", name, namespace)
+	var gitRepository sourcev1.GitRepository
+	err = kubeClient.Get(ctx, namespacedName, &gitRepository)
+	if err != nil {
+		return err
+	}
+
+	if gitRepository.Annotations == nil {
+		gitRepository.Annotations = map[string]string{
+			sourcev1.SyncAtAnnotation: time.Now().String(),
+		}
+	} else {
+		gitRepository.Annotations[sourcev1.SyncAtAnnotation] = time.Now().String()
+	}
+	if err := kubeClient.Update(ctx, &gitRepository); err != nil {
+		return err
+	}
+	logSuccess("source annotated")
+
+	logWaiting("waiting for git sync")
+	if err := wait.PollImmediate(pollInterval, timeout,
+		isGitRepositoryReady(ctx, kubeClient, name, namespace)); err != nil {
+		return err
+	}
+
+	logSuccess("git sync completed")
+
+	err = kubeClient.Get(ctx, namespacedName, &gitRepository)
+	if err != nil {
+		return err
+	}
+
+	if gitRepository.Status.Artifact != nil {
+		logSuccess("fetched revision %s", gitRepository.Status.Artifact.Revision)
+	} else {
+		return fmt.Errorf("git sync failed, artifact not found")
+	}
+	return nil
+}

cmd/tk/uninstall.go

@@ -17,7 +17,7 @@ cluster role bindings and CRDs.`,
 	Example: `  # Dry-run uninstall of all components
    uninstall --dry-run --namespace=gitops-system
 
-  # Uninstall all components and custom resource definitions
+  # Uninstall all components and delete custom resource definitions
   uninstall --crds --namespace=gitops-system
 `,
 	RunE: uninstallCmdRun,