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

Implement sync commands
pull/11/head
Stefan Prodan 5 years ago committed by GitHub
commit 790a483560
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -37,21 +37,40 @@ jobs:
fi fi
- name: Build - name: Build
run: sudo go build -o ./bin/tk ./cmd/tk run: sudo go build -o ./bin/tk ./cmd/tk
- name: Run check e2e tests - name: tk check --pre
run: | run: |
./bin/tk check ./bin/tk check --pre
- name: Run install version e2e tests - name: tk install --version
run: | run: |
./bin/tk install --version=master --namespace=test --verbose ./bin/tk install --version=master --namespace=test --verbose
- name: Run uninstall e2e tests - name: tk uninstall
run: | run: |
./bin/tk uninstall --namespace=test --crds --silent ./bin/tk uninstall --namespace=test --crds --silent
- name: Run dev install e2e tests - name: tk install --manifests
run: | run: |
./bin/tk install --manifests ./manifests/install/ ./bin/tk install --manifests ./manifests/install/
- name: Run create source e2e tests - name: tk create source git
run: |
./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: | 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 sync kustomization podinfo --with-source
- name: tk check
run: |
./bin/tk check
- name: Debug failure - name: Debug failure
if: failure() if: failure()
run: | run: |

@ -69,6 +69,7 @@ func runCheckCmd(cmd *cobra.Command, args []string) error {
return nil return nil
} }
logAction("checking controllers")
if !componentsCheck() { if !componentsCheck() {
checkFailed = true checkFailed = true
} }
@ -202,14 +203,16 @@ func componentsCheck() bool {
ctx, cancel := context.WithTimeout(context.Background(), timeout) ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel() defer cancel()
ok := true
for _, deployment := range components { for _, deployment := range components {
command := fmt.Sprintf("kubectl -n %s rollout status deployment %s --timeout=%s", command := fmt.Sprintf("kubectl -n %s rollout status deployment %s --timeout=%s",
namespace, deployment, timeout.String()) namespace, deployment, timeout.String())
if output, err := utils.execCommand(ctx, ModeCapture, command); err != nil { if output, err := utils.execCommand(ctx, ModeCapture, command); err != nil {
logFailure("%s: %s", deployment, strings.TrimSuffix(output, "\n")) logFailure("%s: %s", deployment, strings.TrimSuffix(output, "\n"))
ok = false
} else { } else {
logSuccess("%s is healthy", deployment) logSuccess("%s is healthy", deployment)
} }
} }
return true return ok
} }

@ -18,8 +18,9 @@ import (
) )
var createKsCmd = &cobra.Command{ var createKsCmd = &cobra.Command{
Use: "kustomization [name]", Use: "kustomization [name]",
Short: "Create or update a kustomization resource", Aliases: []string{"ks"},
Short: "Create or update a kustomization resource",
Long: ` Long: `
The kustomization source command generates a kustomization.kustomize.fluxcd.io resource for a given GitRepository source. The kustomization source command generates a kustomization.kustomize.fluxcd.io resource for a given GitRepository source.
API spec: https://github.com/fluxcd/kustomize-controller/tree/master/docs/spec/v1alpha1`, API spec: https://github.com/fluxcd/kustomize-controller/tree/master/docs/spec/v1alpha1`,
@ -95,7 +96,7 @@ func createKsCmdRun(cmd *cobra.Command, args []string) error {
return err return err
} }
logAction("generating %s kustomization", name) logGenerate("generating kustomization")
emptyAPIGroup := "" emptyAPIGroup := ""
kustomization := kustomizev1.Kustomization{ 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 { if err := upsertKustomization(ctx, kubeClient, kustomization); err != nil {
return err return err
} }
logAction("waiting for kustomization sync") logWaiting("waiting for kustomization sync")
if err := wait.PollImmediate(2*time.Second, timeout, if err := wait.PollImmediate(pollInterval, timeout,
isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil { isKustomizationReady(ctx, kubeClient, name, namespace)); err != nil {
return err return err
} }

@ -1,287 +1,14 @@
package main package main
import ( 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" "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{ var createSourceCmd = &cobra.Command{
Use: "source [name]", Use: "source",
Short: "Create or update a source resource", Short: "Create source commands",
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,
} }
var (
sourceGitURL string
sourceGitBranch string
sourceGitTag string
sourceGitSemver string
sourceUsername string
sourcePassword string
)
func init() { 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) 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
}
}

@ -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
}
}

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

@ -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...))
}

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

@ -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)
}

@ -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
}

@ -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)
}

@ -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
}

@ -17,7 +17,7 @@ cluster role bindings and CRDs.`,
Example: ` # Dry-run uninstall of all components Example: ` # Dry-run uninstall of all components
uninstall --dry-run --namespace=gitops-system 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 uninstall --crds --namespace=gitops-system
`, `,
RunE: uninstallCmdRun, RunE: uninstallCmdRun,

Loading…
Cancel
Save