Tracker for production-readiness approvals

Author: wojtek-t

cmd/kepval/main.go

@@ -24,6 +24,8 @@ import (
 	"k8s.io/enhancements/pkg/kepval/keps"
 )
 
+// TODO: Can we remove this file?
+
 func main() {
 	os.Exit(run(os.Stderr))
 }
@@ -38,13 +40,10 @@ func run(w io.Writer) int {
 		}
 		defer file.Close()
 		kep := parser.Parse(file)
-		// if error is nil we can move on
-		if kep.Error == nil {
-			continue
+		if kep.Error != nil {
+			fmt.Fprintf(w, "%v has an error: %q\n", filename, kep.Error.Error())
+			return 1
 		}
-
-		fmt.Fprintf(w, "%v has an error: %q\n", filename, kep.Error.Error())
-		return 1
 	}
 
 	fmt.Fprintf(w, "No validation errors: %v\n", os.Args[1:])

cmd/kepval/main_test.go

@@ -17,15 +17,18 @@ limitations under the License.
 package main
 
 import (
-	"bytes"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
+
+	"k8s.io/enhancements/pkg/kepval/keps"
+	"k8s.io/enhancements/pkg/kepval/prrs"
 )
 
 const (
 	kepsDir     = "keps"
+	prrsDir     = "keps/prod-readiness"
 	kepMetadata = "kep.yaml"
 )
 
@@ -70,14 +73,61 @@ func TestValidation(t *testing.T) {
 		t.Fatal("must find more than 0 keps")
 	}
 
-	// Overwrite the command line argument for the run() function
-	os.Args = []string{"", ""}
-	for _, file := range files {
-		t.Run(file, func(t *testing.T) {
-			os.Args[1] = file
-			var b bytes.Buffer
-			if exit := run(&b); exit != 0 {
-				t.Fatalf("exit code was %d and not 0. Output:\n%s", exit, b.String())
+	kepParser := &keps.Parser{}
+	prrParser := &prrs.Parser{}
+	prrsDir := filepath.Join("..", "..", prrsDir)
+
+	for _, filename := range files {
+		t.Run(filename, func(t *testing.T) {
+			kepFile, err := os.Open(filename)
+			if err != nil {
+				t.Fatalf("could not open file %s: %v\n", filename, err)
+			}
+			defer kepFile.Close()
+
+			kep := kepParser.Parse(kepFile)
+			if kep.Error != nil {
+				t.Errorf("%v has an error: %v", filename, kep.Error)
+			}
+
+			requiredPRRApproval := len(kep.Number) > 0 && kep.LatestMilestone >= "v1.21"
+			if !requiredPRRApproval {
+				return
+			}
+
+			prrFilename := filepath.Join(prrsDir, kep.OwningSIG, kep.Number)
+			prrFile, err := os.Open(prrFilename)
+			if os.IsNotExist(err) {
+				t.Errorf("missing PRR Approval file under: %s", prrFilename)
+				return
+			}
+			if err != nil {
+				t.Fatalf("could not open file %s: %v\n", prrFilename, err)
+			}
+			prr := prrParser.Parse(prrFile)
+			if prr.Error != nil {
+				t.Errorf("PRR approval file %v has an error: %v", prrFilename, prr.Error)
+				return
+			}
+
+			var stageMilestone string
+			var stagePRRApprover string
+			switch kep.Stage {
+			case "alpha":
+				stageMilestone = kep.Milestone.Alpha
+				stagePRRApprover = prr.Alpha.Approver
+			case "beta":
+				stageMilestone = kep.Milestone.Beta
+				stagePRRApprover = prr.Beta.Approver
+			case "stable":
+				stageMilestone = kep.Milestone.Stable
+				stagePRRApprover = prr.Stable.Approver
+			}
+			if len(stageMilestone) > 0 && stageMilestone >= "v1.21" {
+				// PRR approval is needed.
+				if len(stagePRRApprover) == 0 {
+					t.Errorf("PRR not approved for: %s", kep.Stage)
+				}
 			}
 		})
 	}

keps/prod-readiness/OWNERS

@@ -0,0 +1,8 @@
+# Disable inheritance as this is production-readiness directory.
+options:
+  no_parent_owners: true
+
+approvers:
+  - prod-readiness-approvers
+
+# TODO: Tag PRs with PRR-related label.

keps/prod-readiness/sig-api-machinery/1040.yaml

@@ -0,0 +1,3 @@
+kep-number: 1040
+beta:
+  approver: "@wojtek-t"

pkg/kepval/prrs/approvals.go

@@ -0,0 +1,77 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package prrs
+
+import (
+	"bufio"
+	"bytes"
+	"io"
+
+	"github.com/pkg/errors"
+	"gopkg.in/yaml.v2"
+	"k8s.io/enhancements/pkg/kepval/prrs/validations"
+)
+
+type Approvals []*Approval
+
+func (a *Approvals) AddApproval(approval *Approval) {
+	*a = append(*a, approval)
+}
+
+type Milestone struct {
+	Approver string `json:"approver" yaml:"approver"`
+}
+
+type Approval struct {
+	Number string    `json:"kep-number" yaml:"kep-number"`
+	Alpha  Milestone `json:"alpha" yaml:"alpha"`
+	Beta   Milestone `json:"beta" yaml:"beta"`
+	Stable Milestone `json:"stable" yaml:"stable"`
+
+	Error    error  `json:"-" yaml:"-"`
+}
+
+type Parser struct{}
+
+func (p *Parser) Parse(in io.Reader) *Approval {
+	scanner := bufio.NewScanner(in)
+	var body bytes.Buffer
+	for scanner.Scan() {
+		line := scanner.Text() + "\n"
+		body.WriteString(line)
+	}
+
+	approval := &Approval{}
+	if err := scanner.Err(); err != nil {
+		approval.Error = errors.Wrap(err, "error reading file")
+		return approval
+	}
+
+	// First do structural checks
+	test := map[interface{}]interface{}{}
+	if err := yaml.Unmarshal(body.Bytes(), test); err != nil {
+		approval.Error = errors.Wrap(err, "error unmarshaling YAML")
+		return approval
+	}
+	if err := validations.ValidateStructure(test); err != nil {
+		approval.Error = errors.Wrap(err, "error validating PRR approval metadata")
+		return approval
+	}
+
+	approval.Error = yaml.UnmarshalStrict(body.Bytes(), approval)
+	return approval
+}

pkg/kepval/prrs/approvals_test.go

@@ -0,0 +1,53 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package prrs
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidParsing(t *testing.T) {
+	testcases := []struct {
+		name         string
+		fileContents string
+	}{
+		{
+			"simple test",
+			`
+kep-number: 12345
+beta:
+  approver: "@wojtek-t"
+stable:
+  approver: "johnbelamaric"
+`,
+		},
+	}
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			p := &Parser{}
+			contents := strings.NewReader(tc.fileContents)
+			out := p.Parse(contents)
+			if out.Error != nil {
+				t.Fatalf("expected no error but got one: %v", out.Error)
+			}
+			if out == nil {
+				t.Fatal("out should not be nil")
+			}
+		})
+	}
+}

pkg/kepval/prrs/validations/yaml.go

@@ -0,0 +1,92 @@
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package validations
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"k8s.io/enhancements/pkg/kepval/util"
+)
+
+var (
+	mandatoryKeys = []string{"kep-number"}
+)
+
+func ValidateStructure(parsed map[interface{}]interface{}) error {
+	for _, key := range mandatoryKeys {
+		if _, found := parsed[key]; !found {
+			return util.NewKeyMustBeSpecified(key)
+		}
+	}
+
+	for key, value := range parsed {
+		// First off the key has to be a string. fact.
+		k, ok := key.(string)
+		if !ok {
+			return util.NewKeyMustBeString(k)
+		}
+
+		// figure out the types
+		switch strings.ToLower(k) {
+		case "alpha", "beta", "stable":
+			switch v := value.(type) {
+			case map[interface{}]interface{}:
+				if err := validateMilestone(v); err != nil {
+					return fmt.Errorf("invalid %s field: %v", k, err)
+				}
+			case interface{}:
+				return util.NewValueMustBeStruct(k, v)
+			}
+		}
+	}
+	return nil
+}
+
+func validateMilestone(parsed map[interface{}]interface{}) error {
+	// prrApprovers must be sorted to use SearchStrings down below...
+	prrApprovers := util.PRRApprovers()
+	sort.Strings(prrApprovers)
+
+	for key, value := range parsed {
+		// First off the key has to be a string. fact.
+		k, ok := key.(string)
+		if !ok {
+			return util.NewKeyMustBeString(k)
+		}
+
+		// figure out the types
+		switch strings.ToLower(k) {
+		case "approver":
+			switch v := value.(type) {
+			case []interface{}:
+				return util.NewValueMustBeString(k, v)
+			}
+			v, _ := value.(string)
+			if len(v) > 0 && v[0] == '@' {
+				// If "@" is appeneded at the beginning, remove it.
+				v = v[1:]
+			}
+			index := sort.SearchStrings(prrApprovers, v)
+			if index >= len(prrApprovers) || prrApprovers[index] != v {
+				return util.NewValueMustBeOneOf(k, v, prrApprovers)
+			}
+		}
+	}
+	return nil
+}