Adding a Tide Configuration for checking only github required checks.

prow/cmd/tide/README.md

@@ -0,0 +1,81 @@
+# Tide Documentation
+
+Tide merges PR that match a given sets of criteria
+
+## Tide configuration
+
+Extend the primary prow [`config.yaml`] document to include a top-level
+`tide` key that looks like the following:
+
+```yaml
+
+tide:
+  queries:
+  ...
+  branchProtection:
+  ...
+  merge_method:
+  ...
+
+
+presubmits:
+  kubernetes/test-infra:
+  - name: fancy-job-name
+    context: fancy-job-name
+    always_run: true
+    spec:  # podspec that runs job
+```
+
+
+### Merging Options
+
+Tide supports all 3 github merging options:
+
+* squash
+* merge
+* rebase
+
+A merge method can be set for repo or per org.
+
+Example:
+
+```yaml
+tide:
+  ...
+  merge_method:
+    org1: squash
+    org2/repo1: rebase
+    org2/repo2: merge
+```
+
+### Queries Configuration
+
+Queries are using github queries to find PRs to be merged. Multiple queries can be defined for a single repo. Queries support filtering per existing and missing labels. In order to filter PRs that have been approved, use the reviewApprovedRequired.
+
+```yaml
+tide:
+  queries:
+    ...
+    - repos:
+      - org1/repo1
+      - org2/repo2
+      labels:
+      - labelThatMustsExists
+      - OtherLabelThatMustsExist
+      missingLabels:
+      - labelThatShouldNotBePresent
+     # If you want github approval
+     reviewApprovedRequired: true
+```
+
+### Branch Protection Options
+Branch Protection options are use to enforce github branch protection.
+A PR will be merged when all required checks are passing, meaning we will skip optional contexts.
+
+Example:
+
+```yaml
+tide:
+  ...
+  skip_optional_contexts: true
+```

prow/config/jobs.go

@@ -209,6 +209,14 @@ func (ps Presubmit) TriggerMatches(body string) bool {
 	return ps.re.MatchString(body)
 }
 
+// ContextRequired checks whether a context is required from github points of view (required check).
+func (ps Presubmit) ContextRequired() bool {
+	if ps.Optional || ps.SkipReport {
+		return false
+	}
+	return true
+}
+
 type ChangedFilesProvider func() ([]string, error)
 
 func matching(j Presubmit, body string, testAll bool) []Presubmit {

prow/config/tide.go

@@ -64,6 +64,10 @@ type Tide struct {
 	// controller to handle org/repo:branch pools. Defaults to 20. Needs to be a
 	// positive number.
 	MaxGoroutines int `json:"max_goroutines,omitempty"`
+
+	// SkipOptionalContexts will use BranchProtection configuration options to know
+	// which contexts can be skipped in order to merge a PR.
+	SkipOptionalContexts bool `json:"skip_optional_contexts,omitempty"`
 }
 
 // MergeMethod returns the merge method to use for a repo. The default of merge is

prow/tide/BUILD.bazel

@@ -2,7 +2,10 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = ["tide.go"],
+    srcs = [
+        "contextregister.go",
+        "tide.go",
+    ],
     importpath = "k8s.io/test-infra/prow/tide",
     visibility = ["//visibility:public"],
     deps = [
@@ -33,7 +36,10 @@ filegroup(
 
 go_test(
     name = "go_default_test",
-    srcs = ["tide_test.go"],
+    srcs = [
+        "contextregister_test.go",
+        "tide_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//prow/config:go_default_library",

prow/tide/contextregister.go

@@ -0,0 +1,107 @@
+/*
+Copyright 2018 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 tide
+
+import (
+	"sync"
+
+	"github.com/shurcooL/githubql"
+	"k8s.io/apimachinery/pkg/util/sets"
+)
+
+type contextChecker interface {
+	// ignoreContext tells whether a context is optional.
+	ignoreContext(context Context) bool
+	// missingRequiredContexts tells if required contexts are missing from the list of contexts provided.
+	missingRequiredContexts([]Context) []Context
+}
+
+// newExpectedContext creates a Context with Expected state.
+// This should not only be used when contexts are missing.
+func newExpectedContext(c string) Context {
+	return Context{
+		Context:     githubql.String(c),
+		State:       githubql.StatusStateExpected,
+		Description: githubql.String(""),
+	}
+}
+
+// contextRegister implements contextChecker and allow registering of required and optional contexts.
+type contextRegister struct {
+	lock               sync.RWMutex
+	required, optional sets.String
+}
+
+// newContextRegister instantiates a new contextRegister and register the optional contexts provided.
+func newContextRegister(optional ...string) *contextRegister {
+	r := contextRegister{
+		required: sets.NewString(),
+		optional: sets.NewString(),
+	}
+	r.registerOptionalContexts(optional...)
+	return &r
+}
+
+// ignoreContext checks whether a context can be ignored.
+// Will return true if
+// - context is registered as optional
+// - required contexts are registered and the context provided is not required
+// Will return false otherwise. Every context is required.
+func (r *contextRegister) ignoreContext(c Context) bool {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+	if r.optional.Has(string(c.Context)) {
+		return true
+	}
+	if r.required.Len() > 0 && !r.required.Has(string(c.Context)) {
+		return true
+	}
+	return false
+}
+
+// missingRequiredContexts discard the optional contexts and only look of extra required contexts that are not provided.
+func (r *contextRegister) missingRequiredContexts(contexts []Context) []Context {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+	if r.required.Len() == 0 {
+		return nil
+	}
+	existingContexts := sets.NewString()
+	for _, c := range contexts {
+		existingContexts.Insert(string(c.Context))
+	}
+	var missingContexts []Context
+	for c := range r.required.Difference(existingContexts) {
+		missingContexts = append(missingContexts, newExpectedContext(c))
+	}
+	return missingContexts
+}
+
+// registerOptionalContexts registers optional contexts
+func (r *contextRegister) registerOptionalContexts(c ...string) {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+	r.optional.Insert(c...)
+}
+
+// registerRequiredContexts register required contexts.
+// Once required contexts are registered other contexts will be considered optional.
+func (r *contextRegister) registerRequiredContexts(c ...string) {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+	r.required.Insert(c...)
+}

prow/tide/contextregister_test.go

@@ -0,0 +1,131 @@
+/*
+Copyright 2018 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 tide
+
+import (
+	"testing"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+)
+
+func TestContextRegisterIgnoreContext(t *testing.T) {
+	testCases := []struct {
+		name               string
+		required, optional []string
+		contexts           []string
+		results            []bool
+	}{
+		{
+			name:     "only optional contexts registered",
+			contexts: []string{"c1", "o1", "o2"},
+			optional: []string{"o1", "o2"},
+			results:  []bool{false, true, true},
+		},
+		{
+			name:     "no contexts registered",
+			contexts: []string{"t2"},
+			results:  []bool{false},
+		},
+		{
+			name:     "only required contexts registered",
+			required: []string{"c1", "c2", "c3"},
+			contexts: []string{"c1", "c2", "c3", "t1"},
+			results:  []bool{false, false, false, true},
+		},
+		{
+			name:     "optional and required contexts registered",
+			optional: []string{"o1", "o2"},
+			required: []string{"c1", "c2", "c3"},
+			contexts: []string{"o1", "o2", "c1", "c2", "c3", "t1"},
+			results:  []bool{true, true, false, false, false, true},
+		},
+	}
+
+	for _, tc := range testCases {
+		cr := newContextRegister(tc.optional...)
+		cr.registerRequiredContexts(tc.required...)
+		for i, c := range tc.contexts {
+			if cr.ignoreContext(newExpectedContext(c)) != tc.results[i] {
+				t.Errorf("%s - ignoreContext for %s should return %t", tc.name, c, tc.results[i])
+			}
+		}
+	}
+}
+
+func contextsToSet(contexts []Context) sets.String {
+	s := sets.NewString()
+	for _, c := range contexts {
+		s.Insert(string(c.Context))
+	}
+	return s
+}
+
+func TestContextRegisterMissingContexts(t *testing.T) {
+	testCases := []struct {
+		name                               string
+		required, optional                 []string
+		existingContexts, expectedContexts []string
+	}{
+		{
+			name:             "no contexts registered",
+			existingContexts: []string{"c1", "c2"},
+		},
+		{
+			name:             "optional contexts registered / no missing contexts",
+			optional:         []string{"o1", "o2", "o3"},
+			existingContexts: []string{"c1", "c2"},
+		},
+		{
+			name:             "required  contexts registered / missing contexts",
+			required:         []string{"c1", "c2", "c3"},
+			existingContexts: []string{"c1", "c2"},
+			expectedContexts: []string{"c3"},
+		},
+		{
+			name:             "required contexts registered / no missing contexts",
+			required:         []string{"c1", "c2", "c3"},
+			existingContexts: []string{"c1", "c2", "c3"},
+		},
+		{
+			name:             "optional and required contexts registered / missing contexts",
+			optional:         []string{"o1", "o2", "o3"},
+			required:         []string{"c1", "c2", "c3"},
+			existingContexts: []string{"c1", "c2"},
+			expectedContexts: []string{"c3"},
+		},
+		{
+			name:             "optional and required contexts registered / no missing contexts",
+			optional:         []string{"o1", "o2", "o3"},
+			required:         []string{"c1", "c2"},
+			existingContexts: []string{"c1", "c2", "c4"},
+		},
+	}
+
+	for _, tc := range testCases {
+		cr := newContextRegister(tc.optional...)
+		cr.registerRequiredContexts(tc.required...)
+		var contexts []Context
+		for _, c := range tc.existingContexts {
+			contexts = append(contexts, newExpectedContext(c))
+		}
+		missingContexts := cr.missingRequiredContexts(contexts)
+		m := contextsToSet(missingContexts)
+		if !m.Equal(sets.NewString(tc.expectedContexts...)) {
+			t.Errorf("%s - expected %v got %v", tc.name, tc.expectedContexts, missingContexts)
+		}
+	}
+}