Added missing /cmd directory

Author: jdharmon

.gitignore

@@ -2,4 +2,3 @@
 vendor/
 _output/
 pod-reaper.iml
-pod-reaper

cmd/pod-reaper/app/options.go

@@ -0,0 +1,138 @@
+package app
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/selection"
+
+	"github.com/target/pod-reaper/internal/pkg/rules"
+)
+
+// environment variable names
+const envNamespace = "NAMESPACE"
+const envGracePeriod = "GRACE_PERIOD"
+const envScheduleCron = "SCHEDULE"
+const envRunDuration = "RUN_DURATION"
+const envExcludeLabelKey = "EXCLUDE_LABEL_KEY"
+const envExcludeLabelValues = "EXCLUDE_LABEL_VALUES"
+const envRequireLabelKey = "REQUIRE_LABEL_KEY"
+const envRequireLabelValues = "REQUIRE_LABEL_VALUES"
+
+type options struct {
+	namespace        string
+	gracePeriod      *int64
+	schedule         string
+	runDuration      time.Duration
+	labelExclusion   *labels.Requirement
+	labelRequirement *labels.Requirement
+	rules            rules.Rules
+}
+
+func namespace() string {
+	return os.Getenv(envNamespace)
+}
+
+func gracePeriod() (*int64, error) {
+	envGraceDuration, exists := os.LookupEnv(envGracePeriod)
+	if !exists {
+		return nil, nil
+	}
+	duration, err := time.ParseDuration(envGraceDuration)
+	if err != nil {
+		return nil, fmt.Errorf("invalid %s: %s", envGracePeriod, err)
+	}
+	seconds := int64(duration.Seconds())
+	return &seconds, nil
+}
+
+func envDuration(key string, defValue string) (time.Duration, error) {
+	envDuration, exists := os.LookupEnv(key)
+	if !exists {
+		envDuration = defValue
+	}
+	duration, err := time.ParseDuration(envDuration)
+	if err != nil {
+		return duration, fmt.Errorf("invalid %s: %s", key, err)
+	}
+	return duration, nil
+}
+
+func schedule() string {
+	schedule, exists := os.LookupEnv(envScheduleCron)
+	if !exists {
+		schedule = "@every 1m"
+	}
+	return schedule
+}
+
+func runDuration() (time.Duration, error) {
+	return envDuration(envRunDuration, "0s")
+}
+
+func labelExclusion() (*labels.Requirement, error) {
+	labelKey, labelKeyExists := os.LookupEnv(envExcludeLabelKey)
+	labelValue, labelValuesExist := os.LookupEnv(envExcludeLabelValues)
+	if labelKeyExists && !labelValuesExist {
+		return nil, fmt.Errorf("specified %s but not %s", envExcludeLabelKey, envExcludeLabelValues)
+	} else if !labelKeyExists && labelValuesExist {
+		return nil, fmt.Errorf("did not specify %s but did specify %s", envExcludeLabelKey, envExcludeLabelValues)
+	} else if !labelKeyExists && !labelValuesExist {
+		return nil, nil
+	}
+	labelValues := strings.Split(labelValue, ",")
+	labelExclusion, err := labels.NewRequirement(labelKey, selection.NotIn, labelValues)
+	if err != nil {
+		return nil, fmt.Errorf("could not create exclusion label: %s", err)
+	}
+	return labelExclusion, nil
+}
+
+func labelRequirement() (*labels.Requirement, error) {
+	labelKey, labelKeyExists := os.LookupEnv(envRequireLabelKey)
+	labelValue, labelValuesExist := os.LookupEnv(envRequireLabelValues)
+	if labelKeyExists && !labelValuesExist {
+		return nil, fmt.Errorf("specified %s but not %s", envRequireLabelKey, envRequireLabelValues)
+	} else if !labelKeyExists && labelValuesExist {
+		return nil, fmt.Errorf("did not specify %s but did specify %s", envRequireLabelKey, envRequireLabelValues)
+	} else if !labelKeyExists && !labelValuesExist {
+		return nil, nil
+	}
+	labelValues := strings.Split(labelValue, ",")
+	labelRequirement, err := labels.NewRequirement(labelKey, selection.In, labelValues)
+	if err != nil {
+		return nil, fmt.Errorf("could not create requirement label: %s", err)
+	}
+	return labelRequirement, nil
+}
+
+func loadOptions() (options options, err error) {
+	options.namespace = namespace()
+	options.gracePeriod, err = gracePeriod()
+	if err != nil {
+		return options, err
+	}
+	options.schedule = schedule()
+	options.runDuration, err = runDuration()
+	if err != nil {
+		return options, err
+	}
+	options.labelExclusion, err = labelExclusion()
+	if err != nil {
+		return options, err
+	}
+	options.labelRequirement, err = labelRequirement()
+	if err != nil {
+		return options, err
+	}
+
+	// rules
+	options.rules, err = rules.LoadRules()
+	if err != nil {
+		return options, err
+	}
+	return options, err
+}

cmd/pod-reaper/app/options_test.go

@@ -0,0 +1,179 @@
+package app
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"io/ioutil"
+
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"k8s.io/apimachinery/pkg/labels"
+)
+
+func init() {
+	logrus.SetOutput(ioutil.Discard)
+}
+
+func TestOptions(t *testing.T) {
+	t.Run("namespace", func(t *testing.T) {
+		t.Run("default", func(t *testing.T) {
+			os.Clearenv()
+			namespace := namespace()
+			assert.Equal(t, "", namespace)
+		})
+		t.Run("valid", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envNamespace, "test-namespace")
+			namespace := namespace()
+			assert.Equal(t, "test-namespace", namespace)
+		})
+	})
+	t.Run("grace period", func(t *testing.T) {
+		t.Run("default", func(t *testing.T) {
+			os.Clearenv()
+			gracePeriod, err := gracePeriod()
+			assert.NoError(t, err)
+			assert.Nil(t, gracePeriod)
+		})
+		t.Run("valid", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envGracePeriod, "1m53s999ms")
+			gracePeriod, err := gracePeriod()
+			assert.NoError(t, err)
+			assert.Equal(t, int64(113), *gracePeriod)
+		})
+		t.Run("invalid", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envGracePeriod, "invalid")
+			_, err := gracePeriod()
+			assert.Error(t, err)
+		})
+	})
+	t.Run("schedule", func(t *testing.T) {
+		t.Run("default", func(t *testing.T) {
+			os.Clearenv()
+			schedule := schedule()
+			assert.Equal(t, "@every 1m", schedule)
+		})
+	})
+	t.Run("run duration", func(t *testing.T) {
+		t.Run("default", func(t *testing.T) {
+			os.Clearenv()
+			duration, err := runDuration()
+			assert.NoError(t, err)
+			assert.Equal(t, 0*time.Second, duration)
+		})
+		t.Run("invalid", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envRunDuration, "not-a-duration")
+			_, err := runDuration()
+			assert.Error(t, err)
+		})
+		t.Run("valid", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envRunDuration, "1m58s")
+			duration, err := runDuration()
+			assert.NoError(t, err)
+			assert.Equal(t, 2*time.Minute-2*time.Second, duration)
+		})
+	})
+	t.Run("label exclusion", func(t *testing.T) {
+		t.Run("default", func(t *testing.T) {
+			os.Clearenv()
+			exclusion, err := labelExclusion()
+			assert.NoError(t, err)
+			assert.Nil(t, exclusion)
+		})
+		t.Run("only key", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envExcludeLabelKey, "test-key")
+			_, err := labelExclusion()
+			assert.Error(t, err)
+		})
+		t.Run("only values", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envExcludeLabelValues, "test-value1,test-value2")
+			_, err := labelExclusion()
+			assert.Error(t, err)
+		})
+		t.Run("invalid key", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envExcludeLabelKey, "keys cannot have spaces")
+			os.Setenv(envExcludeLabelValues, "test-value1,test-value2")
+			_, err := labelExclusion()
+			assert.Error(t, err)
+		})
+		t.Run("valid", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envExcludeLabelKey, "test-key")
+			os.Setenv(envExcludeLabelValues, "test-value1,test-value2")
+			exclusion, err := labelExclusion()
+			assert.NoError(t, err)
+			assert.NotNil(t, exclusion)
+			assert.Equal(t, "test-key notin (test-value1,test-value2)", labels.NewSelector().Add(*exclusion).String())
+		})
+	})
+	t.Run("label requirement", func(t *testing.T) {
+		t.Run("default", func(t *testing.T) {
+			os.Clearenv()
+			requirement, err := labelRequirement()
+			assert.NoError(t, err)
+			assert.Nil(t, requirement)
+		})
+		t.Run("only key", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envRequireLabelKey, "test-key")
+			_, err := labelRequirement()
+			assert.Error(t, err)
+		})
+		t.Run("only values", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envRequireLabelValues, "test-value1,test-value2")
+			_, err := labelRequirement()
+			assert.Error(t, err)
+		})
+		t.Run("invalid key", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envRequireLabelKey, "keys cannot have spaces")
+			os.Setenv(envRequireLabelValues, "test-value1,test-value2")
+			_, err := labelRequirement()
+			assert.Error(t, err)
+		})
+		t.Run("valid", func(t *testing.T) {
+			os.Clearenv()
+			os.Setenv(envRequireLabelKey, "test-key")
+			os.Setenv(envRequireLabelValues, "test-value1,test-value2")
+			requirement, err := labelRequirement()
+			assert.NoError(t, err)
+			assert.NotNil(t, requirement)
+			assert.Equal(t, "test-key in (test-value1,test-value2)", labels.NewSelector().Add(*requirement).String())
+		})
+	})
+}
+
+func TestOptionsLoad(t *testing.T) {
+	t.Run("invalid options", func(t *testing.T) {
+		os.Clearenv()
+		os.Setenv(envRunDuration, "invalid")
+		_, err := loadOptions()
+		assert.Error(t, err)
+	})
+	t.Run("no rules", func(t *testing.T) {
+		os.Clearenv()
+		_, err := loadOptions()
+		assert.Error(t, err)
+	})
+	t.Run("valid", func(t *testing.T) {
+		os.Clearenv()
+		// ensure at least one rule loads
+		os.Setenv("CHAOS_CHANCE", "1.0")
+		options, err := loadOptions()
+		assert.NoError(t, err)
+		assert.Equal(t, "@every 1m", options.schedule)
+		assert.Equal(t, 0*time.Second, options.runDuration)
+		assert.Nil(t, options.labelExclusion)
+		assert.Nil(t, options.labelRequirement)
+	})
+}