Allow for configuration policies

Summary:
Implements a rough interface for validating configuration against
arbitrary policy rules. Policies are provided as YAML and passed via the
command line as file paths or remote URIs.

The format of policies is:

    enforcements:
      - path: <path>
        rule: <rule>

Where `<path>` is a YAML-ish path to a config field and `<rule>` is any
expression our config validator understands (expressions built in by the
validator library and custom tags defined in `config.validation.go`).

Example policy:

    enforcements:
      - path: variants.production.base
        rule: oneof=debian:jessie debian:stretch
      - path: variants.production.runs.as
        rule: ne=foo
      - path: variants.production.node.dependencies
        rule: isfalse

Command flag parsing was implemented in `main.go` to support the new
`--policy=uri` flag and improve existing handling of `--version` and the
usage statement.

Test Plan: Run `go test ./...`.

Reviewers: thcipriani, demon, hashar, mmodell, #release-engineering-team

Reviewed By: thcipriani, #release-engineering-team

Tags: #release-engineering-team

Differential Revision: https://phabricator.wikimedia.org/D999

1 files changed, 81 insertions, 0 deletions

diff --git a/vendor/github.com/pborman/getopt/counter.go b/vendor/github.com/pborman/getopt/counter.go
new file mode 100644
index 0000000..8b11ec1
--- /dev/null
+++ b/vendor/github.com/pborman/getopt/counter.go
@@ -0,0 +1,81 @@
+// Copyright 2013 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package getopt
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type counterValue int
+
+func (b *counterValue) Set(value string, opt Option) error {
+	if value == "" {
+		*b++
+	} else {
+		v, err := strconv.ParseInt(value, 0, strconv.IntSize)
+		if err != nil {
+			if e, ok := err.(*strconv.NumError); ok {
+				switch e.Err {
+				case strconv.ErrRange:
+					err = fmt.Errorf("value out of range: %s", value)
+				case strconv.ErrSyntax:
+					err = fmt.Errorf("not a valid number: %s", value)
+				}
+			}
+			return err
+		}
+		*b = counterValue(v)
+	}
+	return nil
+}
+
+func (b *counterValue) String() string {
+	return strconv.Itoa(int(*b))
+}
+
+// Counter creates a counting flag stored as an int.  Each time the option
+// is seen while parsing the value is incremented.  The value of the counter
+// may be explicitly set by using the long form:
+//
+//  --counter=5
+//  --c=5
+//
+// Further instances of the option will increment from the set value.
+func Counter(name rune, helpvalue ...string) *int {
+	return CommandLine.Counter(name, helpvalue...)
+}
+
+func (s *Set) Counter(name rune, helpvalue ...string) *int {
+	var p int
+	s.CounterVarLong(&p, "", name, helpvalue...)
+	return &p
+}
+
+func CounterLong(name string, short rune, helpvalue ...string) *int {
+	return CommandLine.CounterLong(name, short, helpvalue...)
+}
+
+func (s *Set) CounterLong(name string, short rune, helpvalue ...string) *int {
+	var p int
+	s.CounterVarLong(&p, name, short, helpvalue...)
+	return &p
+}
+
+func CounterVar(p *int, name rune, helpvalue ...string) Option {
+	return CommandLine.CounterVar(p, name, helpvalue...)
+}
+
+func (s *Set) CounterVar(p *int, name rune, helpvalue ...string) Option {
+	return s.CounterVarLong(p, "", name, helpvalue...)
+}
+
+func CounterVarLong(p *int, name string, short rune, helpvalue ...string) Option {
+	return CommandLine.CounterVarLong(p, name, short, helpvalue...)
+}
+
+func (s *Set) CounterVarLong(p *int, name string, short rune, helpvalue ...string) Option {
+	return s.VarLong((*counterValue)(p), name, short, helpvalue...).SetFlag()
+}