From f830d0ed6ede762ab3fe38f7d0db620e0133aa15 Mon Sep 17 00:00:00 2001 From: David Eads Date: Tue, 26 Feb 2019 17:27:22 -0500 Subject: [PATCH] bump --- glide.lock | 8 +- .../openshift/api/operator/v1/types.go | 7 ++ .../pkg/operator/status/condition.go | 92 ++++++++++++------- .../pkg/operator/status/status_controller.go | 8 +- .../operator/status/status_controller_test.go | 18 +++- .../golang.org/x/tools/go/packages/golist.go | 23 +++-- 6 files changed, 106 insertions(+), 50 deletions(-) diff --git a/glide.lock b/glide.lock index 13fe567d0..dbce8f3ba 100644 --- a/glide.lock +++ b/glide.lock @@ -1,5 +1,5 @@ hash: 1037ac27126b88282406929754baf3804a68910b4e696ba1c4eb9d33855c246a -updated: 2019-02-26T13:05:30.234674+01:00 +updated: 2019-02-26T17:27:07.906997245-05:00 imports: - name: bitbucket.org/ww/goautoneg version: 75cd24fc2f2c2a2088577d12123ddee5f54e0675 @@ -231,7 +231,7 @@ imports: - name: github.com/NYTimes/gziphandler version: 56545f4a5d46df9a6648819d1664c3a03a13ffdb - name: github.com/openshift/api - version: cec6269883be26556e63500b6df19a0b6691992e + version: c58918e29f89383d2e1467bad7156e2b0c49497f subpackages: - apps - apps/v1 @@ -296,7 +296,7 @@ imports: - operator/informers/externalversions/operator/v1 - operator/listers/operator/v1 - name: github.com/openshift/library-go - version: 23ffddb2eeab32431fc585be3012b54616bf10b6 + version: c7611e224f477630e3b53827298d19c91e9f56e5 subpackages: - pkg/assets - pkg/config/client @@ -428,7 +428,7 @@ imports: subpackages: - rate - name: golang.org/x/tools - version: 2dc4ef2775b8122dd5afe2c18fd6f775e87f89e5 + version: f727befe758c04ce68d52abc6e69ad111e2c6797 subpackages: - container/intsets - name: google.golang.org/appengine diff --git a/vendor/github.com/openshift/api/operator/v1/types.go b/vendor/github.com/openshift/api/operator/v1/types.go index d98dfc619..048f3905e 100644 --- a/vendor/github.com/openshift/api/operator/v1/types.go +++ b/vendor/github.com/openshift/api/operator/v1/types.go @@ -42,13 +42,16 @@ var ( // inside of the Spec struct for your particular operator. type OperatorSpec struct { // managementState indicates whether and how the operator should manage the component + // +optional ManagementState ManagementState `json:"managementState"` // logLevel is an intent based logging for an overall component. It does not give fine grained control, but it is a // simple way to manage coarse grained logging choices that operators have to interpret for their operands. + // +optional LogLevel LogLevel `json:"logLevel"` // operandSpecs provide customization for functional units within the component + // +optional OperandSpecs []OperandSpec `json:"operandSpecs"` // unsupportedConfigOverrides holds a sparse config that will override any previously set options. It only needs to be the fields to override @@ -56,10 +59,12 @@ type OperatorSpec struct { // 1. hardcoded defaults // 2. observedConfig // 3. unsupportedConfigOverrides + // +optional UnsupportedConfigOverrides runtime.RawExtension `json:"unsupportedConfigOverrides"` // observedConfig holds a sparse config that controller has observed from the cluster state. It exists in spec because // it is an input to the level for the operator + // +optional ObservedConfig runtime.RawExtension `json:"observedConfig"` } @@ -94,11 +99,13 @@ type OperandSpec struct { Name string `json:"name"` // operandContainerSpecs are per-container options + // +optional OperandContainerSpecs []OperandContainerSpec `json:"operandContainerSpecs"` // unsupportedResourcePatches are applied to the workload resource for this unit. This is an unsupported // workaround if anything needs to be modified on the workload that is not otherwise configurable. // TODO Decide: alternatively, we could simply include a RawExtension which is used in place of the "normal" default manifest + // +optional UnsupportedResourcePatches []ResourcePatch `json:"unsupportedResourcePatches"` } diff --git a/vendor/github.com/openshift/library-go/pkg/operator/status/condition.go b/vendor/github.com/openshift/library-go/pkg/operator/status/condition.go index 855fcea3a..e409def67 100644 --- a/vendor/github.com/openshift/library-go/pkg/operator/status/condition.go +++ b/vendor/github.com/openshift/library-go/pkg/operator/status/condition.go @@ -11,48 +11,78 @@ import ( // conditionMergeState indicates whether you want to merge all Falses or merge all Trues. For instance, Failures merge // on true, but Available merges on false. Thing of it like an anti-default. -func unionCondition(conditionType string, conditionMergeState operatorv1.ConditionStatus, allConditions ...operatorv1.OperatorCondition) configv1.ClusterOperatorStatusCondition { - var interestingConditions []operatorv1.OperatorCondition +func unionCondition(conditionType string, defaultConditionState operatorv1.ConditionStatus, allConditions ...operatorv1.OperatorCondition) configv1.ClusterOperatorStatusCondition { + var oppositeConditionStatus operatorv1.ConditionStatus + if defaultConditionState == operatorv1.ConditionTrue { + oppositeConditionStatus = operatorv1.ConditionFalse + } else { + oppositeConditionStatus = operatorv1.ConditionTrue + } + + interestingConditions := []operatorv1.OperatorCondition{} + badConditions := []operatorv1.OperatorCondition{} for _, condition := range allConditions { - if strings.HasSuffix(condition.Type, conditionType) && condition.Status == conditionMergeState { + if strings.HasSuffix(condition.Type, conditionType) { interestingConditions = append(interestingConditions, condition) + + if condition.Status == oppositeConditionStatus { + badConditions = append(badConditions, condition) + } } } unionedCondition := operatorv1.OperatorCondition{Type: conditionType, Status: operatorv1.ConditionUnknown} - if len(interestingConditions) > 0 { - unionedCondition.Status = conditionMergeState - var messages []string - latestTransitionTime := metav1.Time{} - for _, condition := range interestingConditions { - if latestTransitionTime.Before(&condition.LastTransitionTime) { - latestTransitionTime = condition.LastTransitionTime - } + if len(interestingConditions) == 0 { + unionedCondition.Status = operatorv1.ConditionUnknown + unionedCondition.Reason = "NoData" + return OperatorConditionToClusterOperatorCondition(unionedCondition) + } - if len(condition.Message) == 0 { - continue - } - for _, message := range strings.Split(condition.Message, "\n") { - messages = append(messages, fmt.Sprintf("%s: %s", condition.Type, message)) - } + if len(badConditions) == 0 { + unionedCondition.Status = defaultConditionState + unionedCondition.Message = unionMessage(interestingConditions) + unionedCondition.Reason = "AsExpected" + unionedCondition.LastTransitionTime = latestTransitionTime(interestingConditions) + + return OperatorConditionToClusterOperatorCondition(unionedCondition) + } + + // at this point we have bad conditions + unionedCondition.Status = oppositeConditionStatus + unionedCondition.Message = unionMessage(badConditions) + unionedCondition.Reason = unionReason(badConditions) + unionedCondition.LastTransitionTime = latestTransitionTime(badConditions) + + return OperatorConditionToClusterOperatorCondition(unionedCondition) +} + +func latestTransitionTime(conditions []operatorv1.OperatorCondition) metav1.Time { + latestTransitionTime := metav1.Time{} + for _, condition := range conditions { + if latestTransitionTime.Before(&condition.LastTransitionTime) { + latestTransitionTime = condition.LastTransitionTime } - if len(messages) > 0 { - unionedCondition.Message = strings.Join(messages, "\n") + } + return latestTransitionTime +} + +func unionMessage(conditions []operatorv1.OperatorCondition) string { + messages := []string{} + for _, condition := range conditions { + if len(condition.Message) == 0 { + continue } - if len(interestingConditions) == 1 { - unionedCondition.Reason = interestingConditions[0].Type - } else { - unionedCondition.Reason = "MultipleConditionsMatching" + for _, message := range strings.Split(condition.Message, "\n") { + messages = append(messages, fmt.Sprintf("%s: %s", condition.Type, message)) } - unionedCondition.LastTransitionTime = latestTransitionTime + } + return strings.Join(messages, "\n") +} +func unionReason(conditions []operatorv1.OperatorCondition) string { + if len(conditions) == 1 { + return conditions[0].Type } else { - if conditionMergeState == operatorv1.ConditionTrue { - unionedCondition.Status = operatorv1.ConditionFalse - } else { - unionedCondition.Status = operatorv1.ConditionTrue - } + return "MultipleConditionsMatching" } - - return OperatorConditionToClusterOperatorCondition(unionedCondition) } diff --git a/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller.go b/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller.go index 98467d2e2..68ebec384 100644 --- a/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller.go +++ b/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller.go @@ -132,10 +132,10 @@ func (c StatusSyncer) sync() error { } clusterOperatorObj.Status.RelatedObjects = c.relatedObjects - configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Failing", operatorv1.ConditionTrue, currentDetailedStatus.Conditions...)) - configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Progressing", operatorv1.ConditionTrue, currentDetailedStatus.Conditions...)) - configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Available", operatorv1.ConditionFalse, currentDetailedStatus.Conditions...)) - configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Upgradeable", operatorv1.ConditionFalse, currentDetailedStatus.Conditions...)) + configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Failing", operatorv1.ConditionFalse, currentDetailedStatus.Conditions...)) + configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Progressing", operatorv1.ConditionFalse, currentDetailedStatus.Conditions...)) + configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Available", operatorv1.ConditionTrue, currentDetailedStatus.Conditions...)) + configv1helpers.SetStatusCondition(&clusterOperatorObj.Status.Conditions, unionCondition("Upgradeable", operatorv1.ConditionTrue, currentDetailedStatus.Conditions...)) // TODO work out removal. We don't always know the existing value, so removing early seems like a bad idea. Perhaps a remove flag. versions := c.versionGetter.GetVersions() diff --git a/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller_test.go b/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller_test.go index 1dc8a4b4f..9d7391fae 100644 --- a/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller_test.go +++ b/vendor/github.com/openshift/library-go/pkg/operator/status/status_controller_test.go @@ -1,7 +1,6 @@ package status import ( - "fmt" "reflect" "strings" "testing" @@ -20,18 +19,28 @@ import ( func TestFailing(t *testing.T) { testCases := []struct { + name string conditions []operatorv1.OperatorCondition expectedFailingStatus configv1.ConditionStatus expectedMessages []string expectedReason string }{ { + name: "no data", + conditions: []operatorv1.OperatorCondition{}, + expectedFailingStatus: configv1.ConditionUnknown, + expectedReason: "NoData", + }, + { + name: "one failing false", conditions: []operatorv1.OperatorCondition{ {Type: "TypeAFailing", Status: operatorv1.ConditionFalse}, }, expectedFailingStatus: configv1.ConditionFalse, + expectedReason: "AsExpected", }, { + name: "one failing true", conditions: []operatorv1.OperatorCondition{ {Type: "TypeAFailing", Status: operatorv1.ConditionTrue}, }, @@ -39,6 +48,7 @@ func TestFailing(t *testing.T) { expectedReason: "TypeAFailing", }, { + name: "two present, one failing", conditions: []operatorv1.OperatorCondition{ {Type: "TypeAFailing", Status: operatorv1.ConditionTrue, Message: "a message from type a"}, {Type: "TypeBFailing", Status: operatorv1.ConditionFalse}, @@ -50,6 +60,7 @@ func TestFailing(t *testing.T) { }, }, { + name: "two present, second one failing", conditions: []operatorv1.OperatorCondition{ {Type: "TypeAFailing", Status: operatorv1.ConditionFalse}, {Type: "TypeBFailing", Status: operatorv1.ConditionTrue, Message: "a message from type b"}, @@ -61,6 +72,7 @@ func TestFailing(t *testing.T) { }, }, { + name: "many present, some failing", conditions: []operatorv1.OperatorCondition{ {Type: "TypeAFailing", Status: operatorv1.ConditionFalse}, {Type: "TypeBFailing", Status: operatorv1.ConditionTrue, Message: "a message from type b\nanother message from type b"}, @@ -76,8 +88,8 @@ func TestFailing(t *testing.T) { }, }, } - for name, tc := range testCases { - t.Run(fmt.Sprintf("%05d", name), func(t *testing.T) { + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { clusterOperatorClient := fake.NewSimpleClientset(&configv1.ClusterOperator{ ObjectMeta: metav1.ObjectMeta{Name: "OPERATOR_NAME", ResourceVersion: "12"}, }) diff --git a/vendor/golang.org/x/tools/go/packages/golist.go b/vendor/golang.org/x/tools/go/packages/golist.go index 2fee7fb1f..e053b5e9c 100644 --- a/vendor/golang.org/x/tools/go/packages/golist.go +++ b/vendor/golang.org/x/tools/go/packages/golist.go @@ -728,9 +728,6 @@ func golistargs(cfg *Config, words []string) []string { // invokeGo returns the stdout of a go command invocation. func invokeGo(cfg *Config, args ...string) (*bytes.Buffer, error) { - if debug { - defer func(start time.Time) { log.Printf("%s for %v", time.Since(start), cmdDebugStr(cfg, args...)) }(time.Now()) - } stdout := new(bytes.Buffer) stderr := new(bytes.Buffer) cmd := exec.CommandContext(cfg.Context, "go", args...) @@ -744,6 +741,12 @@ func invokeGo(cfg *Config, args ...string) (*bytes.Buffer, error) { cmd.Dir = cfg.Dir cmd.Stdout = stdout cmd.Stderr = stderr + if debug { + defer func(start time.Time) { + log.Printf("%s for %v, stderr: <<%s>>\n", time.Since(start), cmdDebugStr(cmd, args...), stderr) + }(time.Now()) + } + if err := cmd.Run(); err != nil { exitErr, ok := err.(*exec.ExitError) if !ok { @@ -777,12 +780,12 @@ func invokeGo(cfg *Config, args ...string) (*bytes.Buffer, error) { // be useful for debugging. Print them if $GOPACKAGESPRINTGOLISTERRORS // is set. if len(stderr.Bytes()) != 0 && os.Getenv("GOPACKAGESPRINTGOLISTERRORS") != "" { - fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cfg, args...), stderr) + fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cmd, args...), stderr) } // debugging if false { - fmt.Fprintf(os.Stderr, "%s stdout: <<%s>>\n", cmdDebugStr(cfg, args...), stdout) + fmt.Fprintf(os.Stderr, "%s stdout: <<%s>>\n", cmdDebugStr(cmd, args...), stdout) } return stdout, nil @@ -797,13 +800,17 @@ func containsGoFile(s []string) bool { return false } -func cmdDebugStr(cfg *Config, args ...string) string { +func cmdDebugStr(cmd *exec.Cmd, args ...string) string { env := make(map[string]string) - for _, kv := range cfg.Env { + for _, kv := range cmd.Env { split := strings.Split(kv, "=") k, v := split[0], split[1] env[k] = v } + var quotedArgs []string + for _, arg := range args { + quotedArgs = append(quotedArgs, strconv.Quote(arg)) + } - return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v PWD=%v go %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["PWD"], args) + return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v PWD=%v go %s", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["PWD"], strings.Join(quotedArgs, " ")) }