add restic integration for doing pod volume backups/restores

Signed-off-by: Steve Kriss <steve@heptio.com>

pkg/util/logging/default_logger.go

@@ -0,0 +1,27 @@
+package logging
+
+import (
+	"github.com/sirupsen/logrus"
+)
+
+// DefaultHooks returns a slice of the default
+// logrus hooks to be used by a logger.
+func DefaultHooks() []logrus.Hook {
+	return []logrus.Hook{
+		&LogLocationHook{},
+		&ErrorLocationHook{},
+	}
+}
+
+// DefaultLogger returns a Logger with the default properties
+// and hooks.
+func DefaultLogger(level logrus.Level) *logrus.Logger {
+	logger := logrus.New()
+	logger.Level = level
+
+	for _, hook := range DefaultHooks() {
+		logger.Hooks.Add(hook)
+	}
+
+	return logger
+}

pkg/util/logging/log_level_flag.go

@@ -0,0 +1,60 @@
+package logging
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/heptio/ark/pkg/cmd/util/flag"
+)
+
+var sortedLogLevels = sortLogLevels()
+
+// LevelFlag is a command-line flag for setting the logrus
+// log level.
+type LevelFlag struct {
+	*flag.Enum
+	defaultValue logrus.Level
+}
+
+// LogLevelFlag constructs a new log level flag.
+func LogLevelFlag(defaultValue logrus.Level) *LevelFlag {
+	return &LevelFlag{
+		Enum:         flag.NewEnum(defaultValue.String(), sortedLogLevels...),
+		defaultValue: defaultValue,
+	}
+}
+
+// Parse returns the flag's value as a logrus.Level.
+func (f *LevelFlag) Parse() logrus.Level {
+	if parsed, err := logrus.ParseLevel(f.String()); err == nil {
+		return parsed
+	}
+
+	// This should theoretically never happen assuming the enum flag
+	// is constructed correctly because the enum flag will not allow
+	//  an invalid value to be set.
+	logrus.Errorf("log-level flag has invalid value %s", strings.ToUpper(f.String()))
+	return f.defaultValue
+}
+
+// sortLogLevels returns a string slice containing all of the valid logrus
+// log levels (based on logrus.AllLevels), sorted in ascending order of severity.
+func sortLogLevels() []string {
+	var (
+		sortedLogLevels  = make([]logrus.Level, len(logrus.AllLevels))
+		logLevelsStrings []string
+	)
+
+	copy(sortedLogLevels, logrus.AllLevels)
+
+	// logrus.Panic has the lowest value, so the compare function uses ">"
+	sort.Slice(sortedLogLevels, func(i, j int) bool { return sortedLogLevels[i] > sortedLogLevels[j] })
+
+	for _, level := range sortedLogLevels {
+		logLevelsStrings = append(logLevelsStrings, level.String())
+	}
+
+	return logLevelsStrings
+}