added execution delete/prune, module update and updated state run to account for new fields

Author: luthermonson

pkg/cli/cmds/executions.go

@@ -3,8 +3,9 @@ package cmds
 import (
 	"encoding/base64"
 	"fmt"
+	"time"
 
-	"github.com/rancher/terraform-controller/pkg/age"
+	"github.com/docker/go-units"
 	v1 "github.com/rancher/terraform-controller/pkg/apis/terraformcontroller.cattle.io/v1"
 	"github.com/rancher/terraform-controller/pkg/gz"
 	"github.com/sirupsen/logrus"
@@ -29,11 +30,18 @@ func ExecutionCommand() cli.Command {
 				Action:    executionList,
 			},
 			{
-				Name:      "delete",
-				Aliases:   []string{"del"},
-				Usage:     "Delete executions for a specific state.",
-				ArgsUsage: "[EXECUTION NAME]",
-				Action:    executionDelete,
+				Name:      "prune",
+				Aliases:   []string{"pr"},
+				Usage:     "Takes a state and will delete all executions aged > <days> , pass --days to change how many days to leave",
+				ArgsUsage: "[STATE NAME]",
+				Action:    executionPrune,
+				Flags: []cli.Flag{
+					cli.IntFlag{
+						Name:  "days",
+						Usage: "How many days of executions you want to keep around, --days 2 will leave the last 48hrs of executions",
+						Value: 7,
+					},
+				},
 			},
 			{
 				Name:      "logs",
@@ -42,6 +50,13 @@ func ExecutionCommand() cli.Command {
 				ArgsUsage: "[EXECUTION NAME]",
 				Action:    logs,
 			},
+			{
+				Name:      "delete",
+				Aliases:   []string{"del"},
+				Usage:     "Delete an execution",
+				ArgsUsage: "[EXECUTION NAME]",
+				Action:    delete,
+			},
 			{
 				Name:      "approve",
 				Aliases:   []string{"a"},
@@ -90,10 +105,19 @@ func logs(c *cli.Context) error {
 	return nil
 }
 
-func executionDelete(c *cli.Context) error {
+func executionPrune(c *cli.Context) error {
 	namespace := c.GlobalString("namespace")
 	kubeConfig := c.GlobalString("kubeconfig")
 
+	days := c.Int("days")
+
+	if days > 0 {
+		days = days * -1
+	}
+
+	now := time.Now()
+	from := now.AddDate(0, 0, days)
+
 	controllers, err := getControllers(kubeConfig, namespace)
 	if err != nil {
 		return err
@@ -114,8 +138,11 @@ func executionDelete(c *cli.Context) error {
 	}
 
 	for _, exec := range execs.Items {
-		err := controllers.executions.Delete(namespace, exec.Name, &metav1.DeleteOptions{})
+		if exec.CreationTimestamp.After(from) {
+			continue
+		}
 		logrus.Info("deleting " + exec.Name)
+		err := controllers.executions.Delete(namespace, exec.Name, &metav1.DeleteOptions{})
 		if err != nil {
 			return err
 		}
@@ -124,6 +151,36 @@ func executionDelete(c *cli.Context) error {
 	return nil
 }
 
+func delete(c *cli.Context) error {
+	namespace := c.GlobalString("namespace")
+	kubeConfig := c.GlobalString("kubeconfig")
+
+	if len(c.Args()) != 1 {
+		return InvalidArgs{}
+	}
+
+	name := c.Args().First()
+
+	controllers, err := getControllers(kubeConfig, namespace)
+	if err != nil {
+		return err
+	}
+
+	_, err = controllers.executions.Get(namespace, name, metav1.GetOptions{})
+	if err != nil {
+		return err
+	}
+
+	err = controllers.executions.Delete(namespace, name, &metav1.DeleteOptions{})
+
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Deleted %s\n", name)
+	return nil
+}
+
 func executionList(c *cli.Context) error {
 	namespace := c.GlobalString("namespace")
 	kubeConfig := c.GlobalString("kubeconfig")
@@ -209,11 +266,12 @@ func runsListToTableStrings(executions *v1.ExecutionList) [][]string {
 			approved = "False"
 		}
 
+		age := units.HumanDuration(time.Now().UTC().Sub(execution.ObjectMeta.CreationTimestamp.Time))
 		values = append(values, []string{
 			execution.Name,
 			execution.Labels["state"],
 			approved,
-			age.Age(execution.ObjectMeta.CreationTimestamp.Time),
+			age,
 		})
 	}
 

pkg/cli/cmds/modules.go

@@ -39,10 +39,41 @@ func ModuleCommand() cli.Command {
 				ArgsUsage: "[NAME]",
 				Action:    deleteModule,
 			},
+			{
+				Name:      "update",
+				Usage:     "Force the handler to update the git content.",
+				ArgsUsage: "[NAME]",
+				Action:    updateModule,
+			},
 		},
 	}
 }
 
+func updateModule(c *cli.Context) error {
+	kubeConfig := c.GlobalString("kubeconfig")
+	namespace := c.GlobalString("namespace")
+
+	controllers, err := getControllers(kubeConfig, namespace)
+	if err != nil {
+		return err
+	}
+
+	args := c.Args()
+	if len(args) != 1 {
+		return InvalidArgs{}
+	}
+
+	moduleName := c.Args()[0]
+
+	module, err := controllers.modules.Get(namespace, moduleName, metav1.GetOptions{})
+	if err != nil {
+		return err
+	}
+
+	v1.ModuleConditionGitUpdated.False(module)
+	_, err = controllers.modules.Update(module)
+	return err
+}
 func moduleList(c *cli.Context) error {
 	kubeConfig := c.GlobalString("kubeconfig")
 	namespace := c.GlobalString("namespace")

pkg/cli/cmds/states.go

@@ -182,9 +182,9 @@ func stateUnlock(c *cli.Context) error {
 
 	for _, secret := range secrets.Items {
 		if secret.Data["lockInfo"] != nil {
-			copy := secret.DeepCopy()
-			copy.Data["lockInfo"] = nil
-			_, err := controllers.secrets.Update(copy)
+			copyObj := secret.DeepCopy()
+			copyObj.Data["lockInfo"] = nil
+			_, err := controllers.secrets.Update(copyObj)
 			if err != nil {
 				return err
 			}
@@ -236,14 +236,16 @@ func runState(c *cli.Context) error {
 
 	state, err := getState(namespace, kubeConfig, name)
 	if err != nil {
+		logrus.Debug(err)
 		return err
 	}
 
-	// Not really an ideal or safe operation.
-	// Need to create something on the execution type to lock
-	state.Spec.Version += 1
+	copyObj := state.DeepCopy()
+	copyObj.Spec.Version += 1
+	copyObj.Status.LastRunHash = ""
+	v1.StateConditionJobDeployed.False(copyObj)
 
-	_, err = saveState(kubeConfig, namespace, state)
+	_, err = saveState(kubeConfig, namespace, copyObj)
 	return err
 }
 
@@ -268,19 +270,13 @@ func deleteState(c *cli.Context) error {
 	}
 
 	if state.DeletionTimestamp != nil {
-		jobName := "job-" + state.Status.ExecutionName
-		job, err := controllers.jobs.Get(namespace, jobName, metav1.GetOptions{})
-		if err == nil && job.Status.Failed > 0 {
-			err := controllers.jobs.Delete(namespace, jobName, &metav1.DeleteOptions{})
-			if err != nil {
-				return err
-			}
-			//trying to delete but the job failed, give the change handler a chance to delete again.
-			state.Status.ExecutionName = ""
-			_, err = controllers.states.Update(state)
-			if err != nil {
-				return err
-			}
+		state.Status.ExecutionName = ""
+		state.Spec.Version += 1
+		state.Status.LastRunHash = ""
+		v1.StateConditionJobDeployed.False(state)
+		_, err = controllers.states.Update(state)
+		if err != nil {
+			return err
 		}
 	}