diff --git a/go.mod b/go.mod index bef50e9e05..0df99f0ed2 100644 --- a/go.mod +++ b/go.mod @@ -39,10 +39,10 @@ require ( github.com/davecgh/go-spew v1.1.1 github.com/google/gofuzz v1.2.0 github.com/kedacore/keda/v2 v2.8.1 - knative.dev/eventing v0.36.1-0.20230309084530-05f6d84ad43c - knative.dev/hack v0.0.0-20230228173453-3de51aff69a3 - knative.dev/pkg v0.0.0-20230309013522-c5dd1d1264ba - knative.dev/reconciler-test v0.0.0-20230307080119-d52257e4e606 + knative.dev/eventing v0.36.7 + knative.dev/hack v0.0.0-20230412013450-4b3f2300c1ad + knative.dev/pkg v0.0.0-20230414154551-53f04b373cc9 + knative.dev/reconciler-test v0.0.0-20230413132853-06956b6259d6 sigs.k8s.io/controller-runtime v0.12.3 ) diff --git a/go.sum b/go.sum index fc3c6d9c8d..60ee6aecd5 100644 --- a/go.sum +++ b/go.sum @@ -1518,14 +1518,14 @@ k8s.io/utils v0.0.0-20200912215256-4140de9c8800/go.mod h1:jPW/WVKK9YHAvNhRxK0md/ k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= k8s.io/utils v0.0.0-20221108210102-8e77b1f39fe2 h1:GfD9OzL11kvZN5iArC6oTS7RTj7oJOIfnislxYlqTj8= k8s.io/utils v0.0.0-20221108210102-8e77b1f39fe2/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= -knative.dev/eventing v0.36.1-0.20230309084530-05f6d84ad43c h1:idpDTj8ipzWAy7kDZSq3uk4taQoOAAWJGKt84ScmqhE= -knative.dev/eventing v0.36.1-0.20230309084530-05f6d84ad43c/go.mod h1:8mo69M3WWCQWNyWb2G+g2Jyeh8eDOiQud4Xd8jLr57Q= -knative.dev/hack v0.0.0-20230228173453-3de51aff69a3 h1:Jt3n+AZsZHZaFhk/A1NnboAvgjV+hvvyeyyuIX/hUx0= -knative.dev/hack v0.0.0-20230228173453-3de51aff69a3/go.mod h1:yk2OjGDsbEnQjfxdm0/HJKS2WqTLEFg/N6nUs6Rqx3Q= -knative.dev/pkg v0.0.0-20230309013522-c5dd1d1264ba h1:THY9ox1maZNYcmvYBJ3hhtjqHp9Ci0fDsF1t+GIoiOo= -knative.dev/pkg v0.0.0-20230309013522-c5dd1d1264ba/go.mod h1:S+KfTInuwEkZSTwvWqrWZV/TEw6ps51GUGaSC1Fnbe0= -knative.dev/reconciler-test v0.0.0-20230307080119-d52257e4e606 h1:gJY32/uUublG1WSFH0QDstxE3aEQiU61JLr+t0uLp5c= -knative.dev/reconciler-test v0.0.0-20230307080119-d52257e4e606/go.mod h1:2472v1Zg0stETnG6t2qpnyiJadgOJHb2iLaAgiOHa68= +knative.dev/eventing v0.36.7 h1:4Rm60LOc9PMh5IXn17iLbVpO0R8i+/1M3Wh8Dpsq3s8= +knative.dev/eventing v0.36.7/go.mod h1:KYXv6I8okKVrCq1EZXlGH+BZhbBEI7TQF86MaDvp7DM= +knative.dev/hack v0.0.0-20230412013450-4b3f2300c1ad h1:+5MpC265m9pjmJl+popG9XO9G1l+Rq1py9ldqBHwA68= +knative.dev/hack v0.0.0-20230412013450-4b3f2300c1ad/go.mod h1:yk2OjGDsbEnQjfxdm0/HJKS2WqTLEFg/N6nUs6Rqx3Q= +knative.dev/pkg v0.0.0-20230414154551-53f04b373cc9 h1:ZozlfXh+jwr+KE/C60thPDOdAVQ3MNRfdsFHbajHIRk= +knative.dev/pkg v0.0.0-20230414154551-53f04b373cc9/go.mod h1:Xa/jM3LpUnfQabS0kKR9sMTaDn4absCVvwkdNlwRwHc= +knative.dev/reconciler-test v0.0.0-20230413132853-06956b6259d6 h1:zUBZkr9kTSzYBasHZw2WnMcBJy5COZS5Xau9ThmByFo= +knative.dev/reconciler-test v0.0.0-20230413132853-06956b6259d6/go.mod h1:JwK7KUivj9TX7gJ6SAFfNxhmAfYc45kyASeRT8OG+pM= pgregory.net/rapid v0.3.3 h1:jCjBsY4ln4Atz78QoBWxUEvAHaFyNDQg9+WU62aCn1U= pgregory.net/rapid v0.3.3/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= diff --git a/vendor/knative.dev/eventing/cmd/event_display/main.go b/vendor/knative.dev/eventing/cmd/event_display/main.go index 4c3c41c8df..e18adfbd91 100644 --- a/vendor/knative.dev/eventing/cmd/event_display/main.go +++ b/vendor/knative.dev/eventing/cmd/event_display/main.go @@ -17,16 +17,11 @@ limitations under the License. package main import ( - "bytes" "context" - "encoding/json" "fmt" - "io" "log" "net/http" - "net/url" "os" - "strconv" "github.com/cloudevents/sdk-go/observability/opencensus/v2/client" cloudevents "github.com/cloudevents/sdk-go/v2" @@ -70,17 +65,8 @@ func main() { } func run(ctx context.Context) { - - requestLoggingEnabled, _ := strconv.ParseBool(os.Getenv("REQUEST_LOGGING_ENABLED")) - if requestLoggingEnabled { - log.Println("Request logging enabled, request logging is not recommended for production since it might log sensitive information") - } - c, err := client.NewClientHTTP( - []cehttp.Option{ - cehttp.WithMiddleware(healthzMiddleware), - cehttp.WithMiddleware(requestLoggingMiddleware(requestLoggingEnabled)), - }, nil, + []cehttp.Option{cehttp.WithMiddleware(healthzMiddleware)}, nil, ) if err != nil { log.Fatal("Failed to create client: ", err) @@ -113,65 +99,3 @@ func healthzMiddleware(next http.Handler) http.Handler { } }) } - -// requestLoggingMiddleware is a cehttp.Middleware which logs incoming requests. -func requestLoggingMiddleware(enabled bool) func(next http.Handler) http.Handler { - return func(next http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { - if enabled { - logRequest(req) - } - next.ServeHTTP(w, req) - }) - } -} - -type LoggableRequest struct { - Method string `json:"method,omitempty"` - URL *url.URL `json:"URL,omitempty"` - Proto string `json:"proto,omitempty"` - ProtoMajor int `json:"protoMajor,omitempty"` - ProtoMinor int `json:"protoMinor,omitempty"` - Header http.Header `json:"headers,omitempty"` - Body string `json:"body,omitempty"` - ContentLength int64 `json:"contentLength,omitempty"` - TransferEncoding []string `json:"transferEncoding,omitempty"` - Host string `json:"host,omitempty"` - Trailer http.Header `json:"trailer,omitempty"` - RemoteAddr string `json:"remoteAddr"` - RequestURI string `json:"requestURI"` -} - -func logRequest(req *http.Request) { - b, err := json.MarshalIndent(toReq(req), "", " ") - if err != nil { - log.Println("failed to marshal request", err) - } - - log.Println(string(b)) -} - -func toReq(req *http.Request) LoggableRequest { - body, err := io.ReadAll(req.Body) - if err != nil { - log.Println("failed to read request body") - } - _ = req.Body.Close() - // Replace the body with a new reader after reading from the original - req.Body = io.NopCloser(bytes.NewBuffer(body)) - return LoggableRequest{ - Method: req.Method, - URL: req.URL, - Proto: req.Proto, - ProtoMajor: req.ProtoMajor, - ProtoMinor: req.ProtoMinor, - Header: req.Header, - Body: string(body), - ContentLength: req.ContentLength, - TransferEncoding: req.TransferEncoding, - Host: req.Host, - Trailer: req.Trailer, - RemoteAddr: req.RemoteAddr, - RequestURI: req.RequestURI, - } -} diff --git a/vendor/knative.dev/eventing/pkg/apis/duck/v1/channelable_types.go b/vendor/knative.dev/eventing/pkg/apis/duck/v1/channelable_types.go index fef82764de..39784fcaf9 100644 --- a/vendor/knative.dev/eventing/pkg/apis/duck/v1/channelable_types.go +++ b/vendor/knative.dev/eventing/pkg/apis/duck/v1/channelable_types.go @@ -67,6 +67,11 @@ type ChannelableStatus struct { // resolved delivery options. // +optional DeliveryStatus `json:",inline"` + // DeadLetterChannel is a KReference and is set by the channel when it supports native error handling via a channel + // Failed messages are delivered here. + // Deprecated in favor of DeliveryStatus, to be removed September 2022. + // +optional + DeadLetterChannel *duckv1.KReference `json:"deadLetterChannel,omitempty"` } var ( diff --git a/vendor/knative.dev/eventing/pkg/apis/duck/v1/zz_generated.deepcopy.go b/vendor/knative.dev/eventing/pkg/apis/duck/v1/zz_generated.deepcopy.go index d91a3ff628..1ba69456ef 100644 --- a/vendor/knative.dev/eventing/pkg/apis/duck/v1/zz_generated.deepcopy.go +++ b/vendor/knative.dev/eventing/pkg/apis/duck/v1/zz_generated.deepcopy.go @@ -117,6 +117,11 @@ func (in *ChannelableStatus) DeepCopyInto(out *ChannelableStatus) { in.AddressStatus.DeepCopyInto(&out.AddressStatus) in.SubscribableStatus.DeepCopyInto(&out.SubscribableStatus) in.DeliveryStatus.DeepCopyInto(&out.DeliveryStatus) + if in.DeadLetterChannel != nil { + in, out := &in.DeadLetterChannel, &out.DeadLetterChannel + *out = new(duckv1.KReference) + **out = **in + } return } diff --git a/vendor/knative.dev/eventing/pkg/apis/messaging/v1/subscription_defaults.go b/vendor/knative.dev/eventing/pkg/apis/messaging/v1/subscription_defaults.go index c2e5e38bec..0e894fc637 100644 --- a/vendor/knative.dev/eventing/pkg/apis/messaging/v1/subscription_defaults.go +++ b/vendor/knative.dev/eventing/pkg/apis/messaging/v1/subscription_defaults.go @@ -34,8 +34,5 @@ func (ss *SubscriptionSpec) SetDefaults(ctx context.Context) { if ss == nil { return } - - ss.Subscriber.SetDefaults(ctx) - ss.Reply.SetDefaults(ctx) ss.Delivery.SetDefaults(ctx) } diff --git a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go index 5e18659854..8586a68acc 100644 --- a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go +++ b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/broker/controller.go @@ -67,15 +67,10 @@ func NewImpl(ctx context.Context, r Interface, classValue string, optionsFns ... lister := brokerInformer.Lister() var promoteFilterFunc func(obj interface{}) bool - var promoteFunc = func(bkt reconciler.Bucket) {} rec := &reconcilerImpl{ LeaderAwareFuncs: reconciler.LeaderAwareFuncs{ PromoteFunc: func(bkt reconciler.Bucket, enq func(reconciler.Bucket, types.NamespacedName)) error { - - // Signal promotion event - promoteFunc(bkt) - all, err := lister.List(labels.Everything()) if err != nil { return err @@ -134,9 +129,6 @@ func NewImpl(ctx context.Context, r Interface, classValue string, optionsFns ... if opts.PromoteFilterFunc != nil { promoteFilterFunc = opts.PromoteFilterFunc } - if opts.PromoteFunc != nil { - promoteFunc = opts.PromoteFunc - } } rec.Recorder = createRecorder(ctx, agentName) diff --git a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/trigger/controller.go b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/trigger/controller.go index 89f35be5fb..81c543f8e6 100644 --- a/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/trigger/controller.go +++ b/vendor/knative.dev/eventing/pkg/client/injection/reconciler/eventing/v1/trigger/controller.go @@ -64,15 +64,10 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF lister := triggerInformer.Lister() var promoteFilterFunc func(obj interface{}) bool - var promoteFunc = func(bkt reconciler.Bucket) {} rec := &reconcilerImpl{ LeaderAwareFuncs: reconciler.LeaderAwareFuncs{ PromoteFunc: func(bkt reconciler.Bucket, enq func(reconciler.Bucket, types.NamespacedName)) error { - - // Signal promotion event - promoteFunc(bkt) - all, err := lister.List(labels.Everything()) if err != nil { return err @@ -130,9 +125,6 @@ func NewImpl(ctx context.Context, r Interface, optionsFns ...controller.OptionsF if opts.PromoteFilterFunc != nil { promoteFilterFunc = opts.PromoteFilterFunc } - if opts.PromoteFunc != nil { - promoteFunc = opts.PromoteFunc - } } rec.Recorder = createRecorder(ctx, agentName) diff --git a/vendor/knative.dev/eventing/pkg/duck/listable.go b/vendor/knative.dev/eventing/pkg/duck/listable.go index 4bb9262c5d..94c0455e29 100644 --- a/vendor/knative.dev/eventing/pkg/duck/listable.go +++ b/vendor/knative.dev/eventing/pkg/duck/listable.go @@ -20,6 +20,7 @@ import ( "context" "fmt" "sync" + "time" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -27,6 +28,7 @@ import ( "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/tools/cache" "knative.dev/pkg/apis/duck" duckv1 "knative.dev/pkg/apis/duck/v1" @@ -55,6 +57,12 @@ type ListableTracker interface { type Track func(corev1.ObjectReference) error type TrackKReference func(duckv1.KReference) error +// NewListableTracker creates a new ListableTracker, backed by a TypedInformerFactory. +// Deprecated: use NewListableTrackerFromTracker instead. +func NewListableTracker(ctx context.Context, getter func(context.Context) duck.InformerFactory, callback func(types.NamespacedName), lease time.Duration) ListableTracker { + return NewListableTrackerFromTracker(ctx, getter, tracker.New(callback, lease)) +} + // NewListableTrackerFromTracker creates a new ListableTracker, backed by a TypedInformerFactory. func NewListableTrackerFromTracker(ctx context.Context, getter func(context.Context) duck.InformerFactory, t tracker.Interface) ListableTracker { return &listableTracker{ diff --git a/vendor/knative.dev/eventing/pkg/kncloudevents/message_sender.go b/vendor/knative.dev/eventing/pkg/kncloudevents/message_sender.go index 1940439adb..2eeecef51f 100644 --- a/vendor/knative.dev/eventing/pkg/kncloudevents/message_sender.go +++ b/vendor/knative.dev/eventing/pkg/kncloudevents/message_sender.go @@ -34,6 +34,12 @@ type HTTPMessageSender struct { Target string } +// Deprecated: Don't use this anymore, now it has the same effect of NewHTTPMessageSenderWithTarget +// If you need to modify the connection args, use ConfigureConnectionArgs sparingly. +func NewHTTPMessageSender(ca *ConnectionArgs, target string) (*HTTPMessageSender, error) { + return NewHTTPMessageSenderWithTarget(target) +} + func NewHTTPMessageSenderWithTarget(target string) (*HTTPMessageSender, error) { return &HTTPMessageSender{Client: getClient(), Target: target}, nil } diff --git a/vendor/knative.dev/eventing/pkg/utils/secret.go b/vendor/knative.dev/eventing/pkg/utils/secret.go index b8063edd9c..26e24ce37f 100644 --- a/vendor/knative.dev/eventing/pkg/utils/secret.go +++ b/vendor/knative.dev/eventing/pkg/utils/secret.go @@ -66,26 +66,11 @@ func CopySecret(corev1Input clientcorev1.CoreV1Interface, srcNS string, srcSecre return nil, fmt.Errorf("error copying the Secret: %s", err) } - tgtSvcAccount, err := tgtNamespaceSvcAcct.Get(context.Background(), svcAccount, metav1.GetOptions{}) + _, err = tgtNamespaceSvcAcct.Patch(context.Background(), svcAccount, types.StrategicMergePatchType, + []byte(`{"imagePullSecrets":[{"name":"`+srcSecretName+`"}]}`), metav1.PatchOptions{}) if err != nil { - return nil, fmt.Errorf("error getting service account %s: %w", svcAccount, err) - } - - for _, secret := range tgtSvcAccount.ImagePullSecrets { - if secret.Name == srcSecretName { - return newSecret, nil - } - } - // Prevent overwriting existing imagePullSecrets - patch := `[{"op":"add","path":"/imagePullSecrets/-","value":{"name":"` + srcSecretName + `"}}]` - if len(tgtSvcAccount.ImagePullSecrets) == 0 { - patch = `[{"op":"add","path":"/imagePullSecrets","value":[{"name":"` + srcSecretName + `"}]}]` - } - _, err = tgtNamespaceSvcAcct.Patch(context.Background(), svcAccount, types.JSONPatchType, - []byte(patch), metav1.PatchOptions{}) - if err != nil { - return nil, fmt.Errorf("patch failed on NS/SA (%s/%s): %w", - tgtNS, svcAccount, err) + return nil, fmt.Errorf("patch failed on NS/SA (%s/%s): %s", + tgtNS, srcSecretName, err) } return newSecret, nil } diff --git a/vendor/knative.dev/eventing/test/e2e/helpers/broker_event_transformation_test_helper.go b/vendor/knative.dev/eventing/test/e2e/helpers/broker_event_transformation_test_helper.go index bbfae53b37..db93f6f76b 100644 --- a/vendor/knative.dev/eventing/test/e2e/helpers/broker_event_transformation_test_helper.go +++ b/vendor/knative.dev/eventing/test/e2e/helpers/broker_event_transformation_test_helper.go @@ -17,13 +17,11 @@ package helpers import ( "context" - "strings" "testing" cloudevents "github.com/cloudevents/sdk-go/v2" . "github.com/cloudevents/sdk-go/v2/test" "github.com/google/uuid" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" testlib "knative.dev/eventing/test/lib" "knative.dev/eventing/test/lib/recordevents" @@ -46,7 +44,6 @@ EventSource ---> Broker ---> Trigger1 -------> Service(Transformation) Note: the number denotes the sequence of the event that flows in this test case. */ -// Deprecated, use reconciler-test based tests. func EventTransformationForTriggerTestHelper( ctx context.Context, t *testing.T, @@ -133,28 +130,3 @@ func EventTransformationForTriggerTestHelper( HasData([]byte(eventBody)), )) } - -// BrokerCreator creates a broker and returns its broker name. -type BrokerCreator func(client *testlib.Client, version string) string - -// ChannelBasedBrokerCreator creates a BrokerCreator that creates a broker based on the channel parameter. -func ChannelBasedBrokerCreator(channel metav1.TypeMeta, brokerClass string) BrokerCreator { - return func(client *testlib.Client, version string) string { - brokerName := strings.ToLower(channel.Kind) - - // create a ConfigMap used by the broker. - config := client.CreateBrokerConfigMapOrFail("config-"+brokerName, &channel) - - switch version { - case "v1": - client.CreateBrokerOrFail(brokerName, - resources.WithBrokerClassForBroker(brokerClass), - resources.WithConfigForBroker(config), - ) - default: - panic("unknown version: " + version) - } - - return brokerName - } -} diff --git a/vendor/knative.dev/eventing/test/e2e/helpers/broker_test_helper.go b/vendor/knative.dev/eventing/test/e2e/helpers/broker_test_helper.go new file mode 100644 index 0000000000..cc2b3c5b5b --- /dev/null +++ b/vendor/knative.dev/eventing/test/e2e/helpers/broker_test_helper.go @@ -0,0 +1,347 @@ +/* +Copyright 2020 The Knative 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 helpers + +import ( + "context" + "fmt" + "net/url" + "sort" + "strings" + "testing" + + cloudevents "github.com/cloudevents/sdk-go/v2" + "github.com/cloudevents/sdk-go/v2/binding/spec" + cetest "github.com/cloudevents/sdk-go/v2/test" + "github.com/google/uuid" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + v1 "knative.dev/eventing/pkg/apis/eventing/v1" + testlib "knative.dev/eventing/test/lib" + "knative.dev/eventing/test/lib/recordevents" + "knative.dev/eventing/test/lib/resources" +) + +type eventTestCase struct { + Type string + Source string + Extensions map[string]interface{} +} + +// ToString converts the test case to a string to create names for different objects (e.g., triggers, services, etc.). +func (tc eventTestCase) String() string { + eventType := tc.Type + eventSource := tc.Source + extensions := tc.Extensions + // Pod names need to be lowercase. We might have an eventType as Any, that is why we lowercase them. + if eventType == v1.TriggerAnyFilter { + eventType = "testany" + } + if eventSource == v1.TriggerAnyFilter { + eventSource = "testany" + } else { + u, _ := url.Parse(eventSource) + eventSource = strings.Split(u.Host, ".")[0] + } + name := strings.ToLower(fmt.Sprintf("%s-%s", eventType, eventSource)) + if len(extensions) > 0 { + name = strings.ToLower(fmt.Sprintf("%s-%s", name, extensionsToString(extensions))) + } + return name +} + +// ToEventMatcher converts the test case to the event matcher +func (tc eventTestCase) ToEventMatcher() cetest.EventMatcher { + var matchers []cetest.EventMatcher + if tc.Type == v1.TriggerAnyFilter { + matchers = append(matchers, cetest.ContainsAttributes(spec.Type)) + } else { + matchers = append(matchers, cetest.HasType(tc.Type)) + } + + if tc.Source == v1.TriggerAnyFilter { + matchers = append(matchers, cetest.ContainsAttributes(spec.Source)) + } else { + matchers = append(matchers, cetest.HasSource(tc.Source)) + } + + for k, v := range tc.Extensions { + if v == v1.TriggerAnyFilter { + matchers = append(matchers, cetest.ContainsExtensions(k)) + } else { + matchers = append(matchers, cetest.HasExtension(k, v)) + } + } + + return cetest.AllOf(matchers...) +} + +// BrokerCreator creates a broker and returns its broker name. +// TestBrokerWithManyTriggers will wait for the broker to become ready. +type BrokerCreator func(client *testlib.Client, version string) string + +// ChannelBasedBrokerCreator creates a BrokerCreator that creates a broker based on the channel parameter. +func ChannelBasedBrokerCreator(channel metav1.TypeMeta, brokerClass string) BrokerCreator { + return func(client *testlib.Client, version string) string { + brokerName := strings.ToLower(channel.Kind) + + // create a ConfigMap used by the broker. + config := client.CreateBrokerConfigMapOrFail("config-"+brokerName, &channel) + + switch version { + case "v1": + client.CreateBrokerOrFail(brokerName, + resources.WithBrokerClassForBroker(brokerClass), + resources.WithConfigForBroker(config), + ) + default: + panic("unknown version: " + version) + } + + return brokerName + } +} + +// If shouldLabelNamespace is set to true this test annotates the testing namespace so that a default broker is created. +// It then binds many triggers with different filtering patterns to the broker created by brokerCreator, and sends +// different events to the broker's address. +// Finally, it verifies that only the appropriate events are routed to the subscribers. +func TestBrokerWithManyTriggers(ctx context.Context, t *testing.T, brokerCreator BrokerCreator, shouldLabelNamespace bool) { + const ( + any = v1.TriggerAnyFilter + eventType1 = "type1" + eventType2 = "type2" + eventSource1 = "http://source1.com" + eventSource2 = "http://source2.com" + // Be careful with the length of extension name and values, + // we use extension name and value as a part of the name of resources like subscriber and trigger, + // the maximum characters allowed of resource name is 63 + extensionName1 = "extname1" + extensionValue1 = "extval1" + extensionName2 = "extname2" + extensionValue2 = "extvalue2" + nonMatchingExtensionName = "nonmatchingextname" + nonMatchingExtensionValue = "nonmatchingextval" + ) + tests := []struct { + name string + // These are the event context attributes and extension attributes that will be send. + eventsToSend []eventTestCase + // These are the event context attributes and extension attributes that triggers will listen to, + // to set in the subscriber and services pod + // The attributes in these test cases will be used as assertions on the receivers + eventFilters []eventTestCase + // TriggerFilter with DeprecatedSourceAndType or not + deprecatedTriggerFilter bool + }{ + { + name: "test default broker with many deprecated triggers", + eventsToSend: []eventTestCase{ + {Type: eventType1, Source: eventSource1}, + {Type: eventType1, Source: eventSource2}, + {Type: eventType2, Source: eventSource1}, + {Type: eventType2, Source: eventSource2}, + }, + eventFilters: []eventTestCase{ + {Type: any, Source: any}, + {Type: eventType1, Source: any}, + {Type: any, Source: eventSource1}, + {Type: eventType1, Source: eventSource1}, + }, + deprecatedTriggerFilter: true, + }, { + name: "test default broker with many attribute triggers", + eventsToSend: []eventTestCase{ + {Type: eventType1, Source: eventSource1}, + {Type: eventType1, Source: eventSource2}, + {Type: eventType2, Source: eventSource1}, + {Type: eventType2, Source: eventSource2}, + }, + eventFilters: []eventTestCase{ + {Type: any, Source: any}, + {Type: eventType1, Source: any}, + {Type: any, Source: eventSource1}, + {Type: eventType1, Source: eventSource1}, + }, + deprecatedTriggerFilter: false, + }, { + name: "test default broker with many attribute and extension triggers", + eventsToSend: []eventTestCase{ + {Type: eventType1, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: extensionValue1}}, + {Type: eventType1, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}}, + {Type: eventType1, Source: eventSource1, Extensions: map[string]interface{}{extensionName2: extensionValue2}}, + {Type: eventType1, Source: eventSource2, Extensions: map[string]interface{}{extensionName1: extensionValue1}}, + {Type: eventType2, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: nonMatchingExtensionValue}}, + {Type: eventType2, Source: eventSource2, Extensions: map[string]interface{}{nonMatchingExtensionName: extensionValue1}}, + {Type: eventType2, Source: eventSource2, Extensions: map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}}, + {Type: eventType2, Source: eventSource2, Extensions: map[string]interface{}{extensionName1: extensionValue1, nonMatchingExtensionName: extensionValue2}}, + }, + eventFilters: []eventTestCase{ + {Type: any, Source: any, Extensions: map[string]interface{}{extensionName1: extensionValue1}}, + {Type: any, Source: any, Extensions: map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}}, + {Type: any, Source: any, Extensions: map[string]interface{}{extensionName2: extensionValue2}}, + {Type: eventType1, Source: any, Extensions: map[string]interface{}{extensionName1: extensionValue1}}, + {Type: any, Source: any, Extensions: map[string]interface{}{extensionName1: any}}, + {Type: any, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: extensionValue1}}, + {Type: any, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}}, + }, + deprecatedTriggerFilter: false, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + client := testlib.Setup(t, true) + defer testlib.TearDown(client) + + if shouldLabelNamespace { + // Label namespace so that it creates the default broker. + if err := client.LabelNamespace(map[string]string{InjectionLabelKey: InjectionEnabledLabelValue}); err != nil { + t.Fatal("Error labeling namespace:", err) + } + } + + brokerName := brokerCreator(client, "v1") + + // Wait for broker ready. + client.WaitForResourceReadyOrFail(brokerName, testlib.BrokerTypeMeta) + + if shouldLabelNamespace { + // Test if namespace reconciler would recreate broker once broker was deleted. + if err := client.Eventing.EventingV1().Brokers(client.Namespace).Delete(context.Background(), brokerName, metav1.DeleteOptions{}); err != nil { + t.Fatal("Can't delete default broker in namespace:", client.Namespace) + } + client.WaitForResourceReadyOrFail(brokerName, testlib.BrokerTypeMeta) + } + + // Let's start event recorders and triggers + eventTrackers := make(map[string]*recordevents.EventInfoStore, len(test.eventFilters)) + for _, event := range test.eventFilters { + // Create event recorder pod and service + subscriberName := "dumper-" + event.String() + eventTracker, _ := recordevents.StartEventRecordOrFail(ctx, client, subscriberName) + eventTrackers[subscriberName] = eventTracker + // Create trigger. + triggerName := "trigger-" + event.String() + client.CreateTriggerOrFail(triggerName, + resources.WithSubscriberServiceRefForTrigger(subscriberName), + resources.WithAttributesTriggerFilter(event.Source, event.Type, event.Extensions), + resources.WithBroker(brokerName), + ) + } + // Wait for all test resources to become ready before sending the events. + client.WaitForAllTestResourcesReadyOrFail(ctx) + + // Map to save the expected matchers per dumper so that we can verify the delivery. + expectedMatchers := make(map[string][]recordevents.EventInfoMatcher) + // Map to save the unexpected matchers per dumper so that we can verify that they weren't delivered. + unexpectedMatchers := make(map[string][]recordevents.EventInfoMatcher) + + // Now we need to send events and populate the expectedMatcher/unexpectedMatchers map, + // in order to assert if I correctly receive only the expected events + for _, eventTestCase := range test.eventsToSend { + // Create cloud event. + // Using event type, source and extensions as part of the body for easier debugging. + eventToSend := cloudevents.NewEvent() + eventToSend.SetID(uuid.New().String()) + eventToSend.SetType(eventTestCase.Type) + eventToSend.SetSource(eventTestCase.Source) + for k, v := range eventTestCase.Extensions { + eventToSend.SetExtension(k, v) + } + + data := fmt.Sprintf(`{"msg":"%s"}`, eventTestCase.String()) + if err := eventToSend.SetData(cloudevents.ApplicationJSON, []byte(data)); err != nil { + t.Fatal("Cannot set the payload of the event:", err.Error()) + } + + // Send event + senderPodName := "sender-" + eventTestCase.String() + client.SendEventToAddressable(ctx, senderPodName, brokerName, testlib.BrokerTypeMeta, eventToSend) + + // Sent event matcher + sentEventMatcher := cetest.AllOf( + cetest.HasId(eventToSend.ID()), + eventTestCase.ToEventMatcher(), + ) + + // Check on every dumper whether we should expect this event or not + for _, eventFilter := range test.eventFilters { + subscriberName := "dumper-" + eventFilter.String() + + if eventFilter.ToEventMatcher()(eventToSend) == nil { + // This filter should match this event + expectedMatchers[subscriberName] = append( + expectedMatchers[subscriberName], + recordevents.MatchEvent(sentEventMatcher), + ) + } else { + // This filter should not match this event + unexpectedMatchers[subscriberName] = append( + unexpectedMatchers[subscriberName], + recordevents.MatchEvent(sentEventMatcher), + ) + } + } + } + + // Let's check that all expected matchers are fulfilled + for subscriberName, matchers := range expectedMatchers { + eventTracker := eventTrackers[subscriberName] + + for _, matcher := range matchers { + // One match per event is enough + eventTracker.AssertAtLeast(1, matcher) + } + } + + // Let's check the unexpected matchers + // NOTE: this check is not really robust because we could receive + // an unexpected event after the check is done + for subscriberName, matchers := range unexpectedMatchers { + eventTracker := eventTrackers[subscriberName] + + for _, matcher := range matchers { + eventTracker.AssertNot(matcher) + } + } + }) + } +} + +func extensionsToString(extensions map[string]interface{}) string { + // Sort extension keys + sortedExtensionNames := make([]string, 0) + for k := range extensions { + sortedExtensionNames = append(sortedExtensionNames, k) + } + sort.Strings(sortedExtensionNames) + + // Write map as string + var sb strings.Builder + for _, sortedExtensionName := range sortedExtensionNames { + sb.WriteString("-") + sb.WriteString(sortedExtensionName) + sb.WriteString("-") + vStr := fmt.Sprintf("%v", extensions[sortedExtensionName]) + if vStr == v1.TriggerAnyFilter { + vStr = "testany" + } + sb.WriteString(vStr) + } + return sb.String() +} diff --git a/vendor/knative.dev/eventing/test/e2e/helpers/channel_chain_test_helper.go b/vendor/knative.dev/eventing/test/e2e/helpers/channel_chain_test_helper.go new file mode 100644 index 0000000000..3f5f8e1148 --- /dev/null +++ b/vendor/knative.dev/eventing/test/e2e/helpers/channel_chain_test_helper.go @@ -0,0 +1,105 @@ +/* +Copyright 2019 The Knative 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 helpers + +import ( + "context" + "fmt" + "testing" + + cloudevents "github.com/cloudevents/sdk-go/v2" + . "github.com/cloudevents/sdk-go/v2/test" + "github.com/google/uuid" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + testlib "knative.dev/eventing/test/lib" + "knative.dev/eventing/test/lib/recordevents" + "knative.dev/eventing/test/lib/resources" +) + +// ChannelChainTestHelper is the helper function for channel_chain_test +// Deprecated, use reconciler-test based tests. +func ChannelChainTestHelper( + ctx context.Context, + t *testing.T, + subscriptionVersion SubscriptionVersion, + channelTestRunner testlib.ComponentsTestRunner, + options ...testlib.SetupClientOption) { + const ( + senderName = "e2e-channelchain-sender" + recordEventsPodName = "e2e-channelchain-recordevents-pod" + ) + channelNames := []string{"e2e-channelchain1", "e2e-channelchain2"} + // subscriptionNames1 corresponds to Subscriptions on channelNames[0] + subscriptionNames1 := []string{"e2e-channelchain-subs11", "e2e-channelchain-subs12"} + // subscriptionNames2 corresponds to Subscriptions on channelNames[1] + subscriptionNames2 := []string{"e2e-channelchain-subs21"} + eventSource := fmt.Sprintf("http://%s.svc/", senderName) + + channelTestRunner.RunTests(t, testlib.FeatureBasic, func(st *testing.T, channel metav1.TypeMeta) { + client := testlib.Setup(st, true, options...) + defer testlib.TearDown(client) + + // create channels + client.CreateChannelsOrFail(channelNames, &channel) + client.WaitForResourcesReadyOrFail(&channel) + + // create loggerPod and expose it as a service + eventTracker, _ := recordevents.StartEventRecordOrFail(ctx, client, recordEventsPodName) + // create subscription to subscribe the channel, and forward the received events to the logger service + switch subscriptionVersion { + case SubscriptionV1: + // create subscriptions that subscribe the first channel, and reply events directly to the second channel + client.CreateSubscriptionsOrFail( + subscriptionNames1, + channelNames[0], + &channel, + resources.WithReplyForSubscription(channelNames[1], &channel), + ) + // create subscriptions that subscribe the second channel, and call the logging service + client.CreateSubscriptionsOrFail( + subscriptionNames2, + channelNames[1], + &channel, + resources.WithSubscriberForSubscription(recordEventsPodName), + ) + default: + t.Fatalf("Invalid subscription version") + } + // wait for all test resources to be ready, so that we can start sending events + client.WaitForAllTestResourcesReadyOrFail(ctx) + + // send CloudEvent to the first channel + event := cloudevents.NewEvent() + event.SetID("test") + event.SetSource(eventSource) + event.SetType(testlib.DefaultEventType) + + body := fmt.Sprintf(`{"msg":"TestSingleEvent %s"}`, uuid.New().String()) + if err := event.SetData(cloudevents.ApplicationJSON, []byte(body)); err != nil { + st.Fatalf("Cannot set the payload of the event: %s", err.Error()) + } + + client.SendEventToAddressable(ctx, senderName, channelNames[0], &channel, event) + + // verify the logger service receives the event + eventTracker.AssertAtLeast(len(subscriptionNames1)*len(subscriptionNames2), recordevents.MatchEvent( + HasSource(eventSource), + HasData([]byte(body)), + )) + }) +} diff --git a/vendor/knative.dev/eventing/test/e2e/helpers/channel_dls_test_helper.go b/vendor/knative.dev/eventing/test/e2e/helpers/channel_dls_test_helper.go index cc1004ae2e..7aca4f83b9 100644 --- a/vendor/knative.dev/eventing/test/e2e/helpers/channel_dls_test_helper.go +++ b/vendor/knative.dev/eventing/test/e2e/helpers/channel_dls_test_helper.go @@ -24,7 +24,14 @@ import ( cloudevents "github.com/cloudevents/sdk-go/v2" . "github.com/cloudevents/sdk-go/v2/test" "github.com/google/uuid" + "k8s.io/apimachinery/pkg/api/equality" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/utils/pointer" + + duckv1 "knative.dev/pkg/apis/duck/v1" + + eventingduckv1 "knative.dev/eventing/pkg/apis/duck/v1" + messagingv1 "knative.dev/eventing/pkg/apis/messaging/v1" testlib "knative.dev/eventing/test/lib" "knative.dev/eventing/test/lib/recordevents" "knative.dev/eventing/test/lib/resources" @@ -92,3 +99,84 @@ func ChannelDeadLetterSinkTestHelper( )) }) } + +// ChannelDeadLetterDefaultSinkTestHelper is the helper function for channel_deadlettersink_test, but setting the delivery from the channel spec +// Deprecated, use reconciler-test based tests. +func ChannelDeadLetterSinkDefaultTestHelper( + ctx context.Context, + t *testing.T, + channelTestRunner testlib.ComponentsTestRunner, + options ...testlib.SetupClientOption) { + const ( + senderName = "e2e-channelchain-sender" + recordEventsPodName = "e2e-channel-dls-recordevents-pod" + channelName = "e2e-channel-dls" + ) + channelGK := messagingv1.SchemeGroupVersion.WithKind("Channel").GroupKind() + // subscriptionNames corresponds to Subscriptions + subscriptionNames := []string{"e2e-channel-dls-subs1"} + + channelTestRunner.RunTests(t, testlib.FeatureBasic, func(st *testing.T, channel metav1.TypeMeta) { + thisChannelGk := channel.GroupVersionKind().GroupKind() + if equality.Semantic.DeepEqual(thisChannelGk, channelGK) { + st.Skip("It doesn't make sense to create a messaging.Channel with a backing messaging.Channel") + return + } + + client := testlib.Setup(st, true, options...) + defer testlib.TearDown(client) + + // create channel + client.CreateChannelWithDefaultOrFail(&messagingv1.Channel{ + ObjectMeta: metav1.ObjectMeta{ + Name: channelName, + Namespace: client.Namespace, + }, + Spec: messagingv1.ChannelSpec{ + ChannelTemplate: &messagingv1.ChannelTemplateSpec{ + TypeMeta: channel, + }, + ChannelableSpec: eventingduckv1.ChannelableSpec{ + Delivery: &eventingduckv1.DeliverySpec{ + DeadLetterSink: &duckv1.Destination{ + Ref: resources.KnativeRefForService(recordEventsPodName, client.Namespace), + }, + Retry: pointer.Int32(10), + }, + }, + }, + }) + client.WaitForResourcesReadyOrFail(&channel) + + // create event logger pod and service as the subscriber + eventTracker, _ := recordevents.StartEventRecordOrFail(ctx, client, recordEventsPodName) + // create subscriptions that subscribe to a service that does not exist + client.CreateSubscriptionsOrFail( + subscriptionNames, + channelName, + &channel, + resources.WithSubscriberForSubscription("does-not-exist"), + ) + + // wait for all test resources to be ready, so that we can start sending events + client.WaitForAllTestResourcesReadyOrFail(ctx) + + // send CloudEvent to the first channel + event := cloudevents.NewEvent() + event.SetID("test") + eventSource := fmt.Sprintf("http://%s.svc/", senderName) + event.SetSource(eventSource) + event.SetType(testlib.DefaultEventType) + body := fmt.Sprintf(`{"msg":"TestChannelDeadLetterSink %s"}`, uuid.New().String()) + if err := event.SetData(cloudevents.ApplicationJSON, []byte(body)); err != nil { + t.Fatal("Cannot set the payload of the event:", err.Error()) + } + client.SendEventToAddressable(ctx, senderName, channelName, &channel, event) + + // check if the logging service receives the correct number of event messages + eventTracker.AssertAtLeast(len(subscriptionNames), recordevents.MatchEvent( + HasSource(eventSource), + HasData([]byte(body)), + )) + }) +} diff --git a/vendor/knative.dev/eventing/test/experimental/features/new_trigger_filters/filters.go b/vendor/knative.dev/eventing/test/experimental/features/new_trigger_filters/filters.go index 0417f3fe91..7a6de223da 100644 --- a/vendor/knative.dev/eventing/test/experimental/features/new_trigger_filters/filters.go +++ b/vendor/knative.dev/eventing/test/experimental/features/new_trigger_filters/filters.go @@ -25,7 +25,7 @@ import ( . "knative.dev/reconciler-test/pkg/eventshub/assert" "knative.dev/reconciler-test/pkg/feature" "knative.dev/reconciler-test/pkg/manifest" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" "knative.dev/eventing/test/rekt/resources/broker" "knative.dev/eventing/test/rekt/resources/trigger" @@ -72,7 +72,7 @@ func FiltersFeatureSet(brokerName string) *feature.FeatureSet { // Set the Trigger subscriber. cfg := []manifest.CfgFn{ - trigger.WithSubscriber(service.AsKReference(subscriber), ""), + trigger.WithSubscriber(svc.AsKReference(subscriber), ""), WithNewFilters(fs.filters), } diff --git a/vendor/knative.dev/eventing/test/rekt/features/broker/control_plane.go b/vendor/knative.dev/eventing/test/rekt/features/broker/control_plane.go index f36396370b..95b20831ee 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/broker/control_plane.go +++ b/vendor/knative.dev/eventing/test/rekt/features/broker/control_plane.go @@ -33,8 +33,8 @@ import ( "knative.dev/reconciler-test/pkg/environment" "knative.dev/reconciler-test/pkg/feature" "knative.dev/reconciler-test/pkg/manifest" - "knative.dev/reconciler-test/pkg/resources/service" "knative.dev/reconciler-test/pkg/state" + "knative.dev/reconciler-test/resources/svc" v1 "knative.dev/eventing/pkg/apis/duck/v1" eventingv1 "knative.dev/eventing/pkg/apis/eventing/v1" @@ -43,6 +43,7 @@ import ( "knative.dev/eventing/test/rekt/features/knconf" triggerfeatures "knative.dev/eventing/test/rekt/features/trigger" "knative.dev/eventing/test/rekt/resources/broker" + brokerresources "knative.dev/eventing/test/rekt/resources/broker" "knative.dev/eventing/test/rekt/resources/delivery" triggerresources "knative.dev/eventing/test/rekt/resources/trigger" ) @@ -82,26 +83,23 @@ func ControlPlaneBroker(brokerName string, brokerOpts ...manifest.CfgFn) *featur f.Setup("Set Broker Name", setBrokerName(bName)) - f.Setup("install a service", service.Install(sink, - service.WithSelectors(map[string]string{"app": "rekt"}))) - brokerOpts = append(brokerOpts, broker.WithEnvConfig()...) - brokerOpts = append(brokerOpts, delivery.WithDeadLetterSink(service.AsKReference(sink), "")) + f.Setup("install a service", svc.Install(sink, "app", "rekt")) + brokerOpts = append(brokerOpts, brokerresources.WithEnvConfig()...) + brokerOpts = append(brokerOpts, delivery.WithDeadLetterSink(svc.AsKReference(sink), "")) f.Setup("update broker", broker.Install(bName, brokerOpts...)) f.Setup("broker goes ready", broker.IsReady(bName)) f.Stable("Conformance"). Should("Broker objects SHOULD include a Ready condition in their status", - knconf.KResourceHasReadyInConditions(broker.GVR(), brokerName)). + knconf.KResourceHasReadyInConditions(brokerresources.GVR(), brokerName)). Should("The Broker SHOULD indicate Ready=True when its ingress is available to receive events.", readyBrokerHasIngressAvailable). Should("While a Broker is Ready, it SHOULD be a valid Addressable and its `status.address.url` field SHOULD indicate the address of its ingress.", readyBrokerIsAddressable). - Must("The class of a Broker object MUST be immutable.", + Should("The class of a Broker object SHOULD be immutable.", brokerClassIsImmutable). Should("Set the Broker status.deadLetterSinkURI if there is a valid spec.delivery.deadLetterSink defined", - BrokerStatusDLSURISet). - Must("Broker config MUST be immutable.", - brokerConfigIsImmutable) + BrokerStatusDLSURISet) return f } @@ -110,12 +108,11 @@ func ControlPlaneTrigger_GivenBroker(brokerName string) *feature.Feature { f.Setup("Set Broker Name", setBrokerName(brokerName)) subscriberName := feature.MakeRandomK8sName("sub") - f.Setup("Install Subscriber", service.Install(subscriberName, - service.WithSelectors(map[string]string{"bad": "svc"}))) + f.Setup("Install Subscriber", svc.Install(subscriberName, "bad", "svc")) triggerName := feature.MakeRandomK8sName("trigger") f.Setup("Create a Trigger", triggerresources.Install(triggerName, brokerName, - triggerresources.WithSubscriber(service.AsKReference(subscriberName), ""), + triggerresources.WithSubscriber(svc.AsKReference(subscriberName), ""), )) f.Setup("Set Trigger Name", triggerfeatures.SetTriggerName(triggerName)) @@ -138,12 +135,11 @@ func ControlPlaneTrigger_GivenBrokerTriggerReady(brokerName string) *feature.Fea f.Setup("Set Broker Name", setBrokerName(brokerName)) subscriberName := feature.MakeRandomK8sName("sub") - f.Setup("Install Subscriber", service.Install(subscriberName, - service.WithSelectors(map[string]string{"bad": "svc"}))) + f.Setup("Install Subscriber", svc.Install(subscriberName, "bad", "svc")) triggerName := feature.MakeRandomK8sName("trigger") f.Setup("Create a Trigger", triggerresources.Install(triggerName, brokerName, - triggerresources.WithSubscriber(service.AsKReference(subscriberName), ""), + triggerresources.WithSubscriber(svc.AsKReference(subscriberName), ""), )) f.Setup("Set Trigger Name", triggerfeatures.SetTriggerName(triggerName)) @@ -161,27 +157,26 @@ func ControlPlaneTrigger_WithBrokerLifecycle(brokerOpts ...manifest.CfgFn) *feat f := feature.NewFeatureNamed("Trigger, With Broker Lifecycle") subscriberName := feature.MakeRandomK8sName("sub") - f.Setup("Install Subscriber", service.Install(subscriberName, - service.WithSelectors(map[string]string{"bad": "svc"}))) + f.Setup("Install Subscriber", svc.Install(subscriberName, "bad", "svc")) brokerName := feature.MakeRandomK8sName("broker") triggerName := feature.MakeRandomK8sName("trigger") f.Setup("Create a Trigger", triggerresources.Install(triggerName, brokerName, - triggerresources.WithSubscriber(service.AsKReference(subscriberName), ""), + triggerresources.WithSubscriber(svc.AsKReference(subscriberName), ""), )) f.Setup("Set Trigger Name", triggerfeatures.SetTriggerName(triggerName)) - brokerOpts = append(brokerOpts, broker.WithEnvConfig()...) + brokerOpts = append(brokerOpts, brokerresources.WithEnvConfig()...) f.Stable("Conformance"). May("A Trigger MAY be created before its assigned Broker exists.", triggerHasOneBroker). Should("A Trigger SHOULD progress to Ready when its assigned Broker exists and is Ready.", func(ctx context.Context, t feature.T) { - broker.Install(brokerName, brokerOpts...)(ctx, t) // Default broker from Env. - broker.IsReady(brokerName)(ctx, t) + brokerresources.Install(brokerName, brokerOpts...)(ctx, t) // Default broker from Env. + brokerresources.IsReady(brokerName)(ctx, t) triggerresources.IsReady(triggerName)(ctx, t) }) return f @@ -192,8 +187,7 @@ func ControlPlaneTrigger_WithValidFilters(brokerName string) *feature.Feature { f.Setup("Set Broker Name", setBrokerName(brokerName)) subscriberName := feature.MakeRandomK8sName("sub") - f.Setup("Install Subscriber", service.Install(subscriberName, - service.WithSelectors(map[string]string{"bad": "svc"}))) + f.Setup("Install Subscriber", svc.Install(subscriberName, "bad", "svc")) // CloudEvents attribute names MUST consist of lower-case letters ('a' to 'z') or digits ('0' to '9') from the ASCII character set. Attribute names SHOULD be descriptive and terse and SHOULD NOT exceed 20 characters in length. filters := map[string]string{ @@ -212,7 +206,7 @@ func ControlPlaneTrigger_WithValidFilters(brokerName string) *feature.Feature { triggerName := feature.MakeRandomK8sName("trigger") f.Setup("Create a Trigger", triggerresources.Install(triggerName, brokerName, - triggerresources.WithSubscriber(service.AsKReference(subscriberName), ""), + triggerresources.WithSubscriber(svc.AsKReference(subscriberName), ""), triggerresources.WithFilter(filters), )) @@ -243,8 +237,7 @@ func ControlPlaneTrigger_WithInvalidFilters(brokerName string) *feature.Feature f.Setup("Set Broker Name", setBrokerName(brokerName)) subscriberName := feature.MakeRandomK8sName("sub") - f.Setup("Install Subscriber", service.Install(subscriberName, - service.WithSelectors(map[string]string{"bad": "svc"}))) + f.Setup("Install Subscriber", svc.Install(subscriberName, "bad", "svc")) // CloudEvents attribute names MUST consist of lower-case letters ('a' to 'z') or digits ('0' to '9') from the ASCII character set. Attribute names SHOULD be descriptive and terse and SHOULD NOT exceed 20 characters in length. filters := map[string]string{ @@ -262,7 +255,7 @@ func ControlPlaneTrigger_WithInvalidFilters(brokerName string) *feature.Feature triggerName := feature.MakeRandomK8sName("trigger") f.Setup("Create a Trigger", triggerresources.Install(triggerName, brokerName, - triggerresources.WithSubscriber(service.AsKReference(subscriberName), ""), + triggerresources.WithSubscriber(svc.AsKReference(subscriberName), ""), )) f.Setup("Set Trigger Name", triggerfeatures.SetTriggerName(triggerName)) @@ -581,19 +574,6 @@ func getBroker(ctx context.Context, t feature.T) *eventingv1.Broker { return broker } -func copyBroker(ctx context.Context, srcBroker *eventingv1.Broker, toName string) (*eventingv1.Broker, error) { - broker := &eventingv1.Broker{ - ObjectMeta: metav1.ObjectMeta{ - Name: toName, - Labels: srcBroker.Labels, - Annotations: srcBroker.Annotations, - }, - Spec: *srcBroker.Spec.DeepCopy(), - } - - return Client(ctx).Brokers.Create(ctx, broker, metav1.CreateOptions{}) -} - func readyBrokerHasIngressAvailable(ctx context.Context, t feature.T) { // TODO: I am not sure how to test this from the outside. } @@ -641,29 +621,6 @@ func brokerClassIsImmutable(ctx context.Context, t feature.T) { } } -func brokerConfigIsImmutable(ctx context.Context, t feature.T) { - broker := getBroker(ctx, t) - - brokerCopyName := feature.MakeRandomK8sName("broker-copy") - brokerCopy, err := copyBroker(ctx, broker, brokerCopyName) - if err != nil { - t.Errorf("could not create broker copy to test immutability: %v", err) - } - - brokerCopy.Spec = eventingv1.BrokerSpec{ - Config: &duckv1.KReference{ - Kind: "kind", - Namespace: "namespace", - Name: "name", - APIVersion: "apiversion", - }, - } - - if _, err := Client(ctx).Brokers.Update(ctx, brokerCopy, metav1.UpdateOptions{}); err == nil { - t.Errorf("broker.spec.config is mutable") - } -} - func triggerHasReadyInConditions(ctx context.Context, t feature.T) { name := state.GetStringOrFail(ctx, t, triggerfeatures.TriggerNameKey) knconf.KResourceHasReadyInConditions(triggerresources.GVR(), name)(ctx, t) diff --git a/vendor/knative.dev/eventing/test/rekt/features/broker/feature.go b/vendor/knative.dev/eventing/test/rekt/features/broker/feature.go index 58ff8bc2b3..3db39ec806 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/broker/feature.go +++ b/vendor/knative.dev/eventing/test/rekt/features/broker/feature.go @@ -19,11 +19,10 @@ package broker import ( "context" "encoding/base64" - "fmt" "strings" cloudevents "github.com/cloudevents/sdk-go/v2" - "github.com/cloudevents/sdk-go/v2/binding/spec" + "github.com/cloudevents/sdk-go/v2/test" "github.com/google/uuid" @@ -33,185 +32,16 @@ import ( "knative.dev/eventing/test/rekt/resources/channel" "knative.dev/eventing/test/rekt/resources/subscription" "knative.dev/eventing/test/rekt/resources/trigger" - - v1 "knative.dev/pkg/apis/duck/v1" + eventingduckv1 "knative.dev/pkg/apis/duck/v1" "knative.dev/pkg/ptr" "knative.dev/reconciler-test/pkg/eventshub" eventasssert "knative.dev/reconciler-test/pkg/eventshub/assert" "knative.dev/reconciler-test/pkg/feature" "knative.dev/reconciler-test/pkg/manifest" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" ) -func BrokerWithManyTriggers() *feature.Feature { - f := feature.NewFeatureNamed("broker With Many Triggers") - - // Construct different type, source and extensions of events - any := eventingv1.TriggerAnyFilter - eventType1 := "type1" - eventType2 := "type2" - eventSource1 := "http://source1.com" - eventSource2 := "http://source2.com" - // Be careful with the length of extension name and values, - // we use extension name and value as a part of the name of resources like subscriber and trigger, - // the maximum characters allowed of resource name is 63 - extensionName1 := "extname1" - extensionValue1 := "extval1" - extensionName2 := "extname2" - extensionValue2 := "extvalue2" - nonMatchingExtensionName := "nonmatchingextname" - nonMatchingExtensionValue := "nonmatchingextval" - - eventFilters1 := make(map[string]eventTestCase) - eventFilters1["dumper-1"] = neweventTestCase(any, any) - eventFilters1["dumper-12"] = neweventTestCase(eventType1, any) - eventFilters1["dumper-123"] = neweventTestCase(any, eventSource1) - eventFilters1["dumper-1234"] = neweventTestCase(eventType1, eventSource1) - - eventFilters2 := make(map[string]eventTestCase) - eventFilters2["dumper-12345"] = neweventTestCaseWithExtensions(any, any, map[string]interface{}{extensionName1: extensionValue1}) - eventFilters2["dumper-123456"] = neweventTestCaseWithExtensions(any, any, map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}) - eventFilters2["dumper-1234567"] = neweventTestCaseWithExtensions(any, any, map[string]interface{}{extensionName2: extensionValue2}) - eventFilters2["dumper-654321"] = neweventTestCaseWithExtensions(eventType1, any, map[string]interface{}{extensionName1: extensionValue1}) - eventFilters2["dumper-54321"] = neweventTestCaseWithExtensions(any, any, map[string]interface{}{extensionName1: any}) - eventFilters2["dumper-4321"] = neweventTestCaseWithExtensions(any, eventSource1, map[string]interface{}{extensionName1: extensionValue1}) - eventFilters2["dumper-321"] = neweventTestCaseWithExtensions(any, eventSource1, map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}) - eventFilters2["dumper-21"] = neweventTestCaseWithExtensions(any, eventSource2, map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue1}) - - tests := []struct { - name string - // These are the event context attributes and extension attributes that will be send. - eventsToSend []eventTestCase - // These are the event context attributes and extension attributes that triggers will listen to - // This map is to configure sink and corresponding filter to construct trigger - eventFilters map[string]eventTestCase - }{ - { - name: "test default broker with many attribute triggers", - eventsToSend: []eventTestCase{ - {Type: eventType1, Source: eventSource1}, - {Type: eventType1, Source: eventSource2}, - {Type: eventType2, Source: eventSource1}, - {Type: eventType2, Source: eventSource2}, - }, - eventFilters: eventFilters1, - }, - { - name: "test default broker with many attribute and extension triggers", - eventsToSend: []eventTestCase{ - {Type: eventType1, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: extensionValue1}}, - {Type: eventType1, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}}, - {Type: eventType1, Source: eventSource1, Extensions: map[string]interface{}{extensionName2: extensionValue2}}, - {Type: eventType1, Source: eventSource2, Extensions: map[string]interface{}{extensionName1: extensionValue1}}, - {Type: eventType2, Source: eventSource1, Extensions: map[string]interface{}{extensionName1: nonMatchingExtensionValue}}, - {Type: eventType2, Source: eventSource2, Extensions: map[string]interface{}{nonMatchingExtensionName: extensionValue1}}, - {Type: eventType2, Source: eventSource2, Extensions: map[string]interface{}{extensionName1: extensionValue1, extensionName2: extensionValue2}}, - {Type: eventType2, Source: eventSource2, Extensions: map[string]interface{}{extensionName1: extensionValue1, nonMatchingExtensionName: extensionValue2}}, - }, - eventFilters: eventFilters2, - }, - } - - // Map to save the expected matchers per dumper so that we can verify the delivery. - // matcherBySink is to verify the sink and corresponding matcher - matcherBySink := make(map[string][]eventshub.EventInfoMatcher) - - // Create the broker - brokerName := feature.MakeRandomK8sName("broker") - f.Setup("install broker", broker.Install(brokerName, broker.WithEnvConfig()...)) - f.Setup("broker is ready", broker.IsReady(brokerName)) - f.Setup("broker is addressable", broker.IsAddressable(brokerName)) - - for _, testcase := range tests { - for sink, eventFilter := range testcase.eventFilters { - f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) - filter := eventingv1.TriggerFilterAttributes{ - "type": eventFilter.Type, - "source": eventFilter.Source, - } - - // Point the Trigger subscriber to the sink svc. - cfg := []manifest.CfgFn{ - trigger.WithSubscriber(service.AsKReference(sink), ""), - trigger.WithFilter(filter), - trigger.WithExtensions(eventFilter.Extensions), - } - - // Install the trigger - via := feature.MakeRandomK8sName("via") - f.Setup("install trigger", trigger.Install(via, brokerName, cfg...)) - f.Setup("trigger goes ready", trigger.IsReady(via)) - } - - for _, event := range testcase.eventsToSend { - eventToSend := cloudevents.NewEvent() - eventToSend.SetID(uuid.New().String()) - eventToSend.SetType(event.Type) - eventToSend.SetSource(event.Source) - for k, v := range event.Extensions { - eventToSend.SetExtension(k, v) - } - data := fmt.Sprintf(`{"msg":"%s"}`, uuid.New()) - eventToSend.SetData(cloudevents.ApplicationJSON, []byte(data)) - - source := feature.MakeRandomK8sName("source") - f.Requirement("install source", eventshub.Install( - source, - eventshub.StartSenderToResource(broker.GVR(), brokerName), - eventshub.InputEvent(eventToSend), - )) - - // Sent event matcher - sentEventMatcher := test.AllOf( - test.HasId(eventToSend.ID()), - event.toEventMatcher(), - ) - - // Check on every dumper whether we should expect this event or not - for sink, eventFilter := range testcase.eventFilters { - - if eventFilter.toEventMatcher()(eventToSend) == nil { - // This filter should match this event - matcherBySink[sink] = append( - matcherBySink[sink], - eventasssert.MatchEvent(sentEventMatcher), - ) - } - } - } - - // Let's check that all expected matchers are fulfilled - for sink, matchers := range matcherBySink { - for _, matcher := range matchers { - // One match per event is enough - f.Stable("test message without explicit prefer header should have the header"). - Must("delivers events", - eventasssert.OnStore(sink).Match( - matcher, - ).AtLeast(1)) - } - } - } - - return f -} - -func BrokerWorkFlowWithTransformation() *feature.FeatureSet { - createSubscriberFn := func(ref *v1.KReference, uri string) manifest.CfgFn { - return subscription.WithSubscriber(ref, uri) - } - fs := &feature.FeatureSet{ - Name: "Knative Broker - Transformation - Channel flow and Trigger event flow", - - Features: []*feature.Feature{ - brokerChannelFlowWithTransformation(createSubscriberFn), - brokerEventTransformationForTrigger(), - }, - } - return fs -} - /* BrokerChannelFlowWithTransformation tests the following topology: ------------- ---------------------- @@ -230,7 +60,7 @@ Trigger2 logs all events, Trigger3 filters the transformed event and sends it to Channel. */ -func brokerChannelFlowWithTransformation(createSubscriberFn func(ref *v1.KReference, uri string) manifest.CfgFn) *feature.Feature { +func BrokerChannelFlowWithTransformation(createSubscriberFn func(ref *eventingduckv1.KReference, uri string) manifest.CfgFn) *feature.Feature { f := feature.NewFeatureNamed("Broker topology of transformation") source := feature.MakeRandomK8sName("source") @@ -291,7 +121,7 @@ func brokerChannelFlowWithTransformation(createSubscriberFn func(ref *v1.KRefere trigger1, brokerName, trigger.WithFilter(filter1), - trigger.WithSubscriber(service.AsKReference(sink1), ""), + trigger.WithSubscriber(svc.AsKReference(sink1), ""), )) f.Setup("trigger1 goes ready", trigger.IsReady(trigger1)) // Install the trigger2 point to Broker to filter all the events @@ -299,7 +129,7 @@ func brokerChannelFlowWithTransformation(createSubscriberFn func(ref *v1.KRefere trigger2, brokerName, trigger.WithFilter(filter2), - trigger.WithSubscriber(service.AsKReference(sink2), ""), + trigger.WithSubscriber(svc.AsKReference(sink2), ""), )) f.Setup("trigger2 goes ready", trigger.IsReady(trigger2)) @@ -311,7 +141,7 @@ func brokerChannelFlowWithTransformation(createSubscriberFn func(ref *v1.KRefere sub := feature.MakeRandomK8sName("subscription") f.Setup("install subscription", subscription.Install(sub, subscription.WithChannel(channel.AsRef(channelName)), - createSubscriberFn(service.AsKReference(sink3), ""), + createSubscriberFn(svc.AsKReference(sink3), ""), )) f.Setup("subscription is ready", subscription.IsReady(sub)) f.Setup("channel is ready", channel.IsReady(channelName)) @@ -361,117 +191,6 @@ func brokerChannelFlowWithTransformation(createSubscriberFn func(ref *v1.KRefere return f } -/* -BrokerEventTransformationForTrigger tests the following scenario: - - 5 4 - ------------- ---------------------- - | | | | - 1 v 2 | v 3 | - -EventSource ---> Broker ---> Trigger1 -------> Sink1(Transformation) - - | - | 6 7 - |-------> Trigger2 -------> Sink2(Logger) - -Note: the number denotes the sequence of the event that flows in this test case. -*/ -func brokerEventTransformationForTrigger() *feature.Feature { - f := feature.NewFeatureNamed("Broker event transformation for trigger") - - source := feature.MakeRandomK8sName("source") - sink1 := feature.MakeRandomK8sName("sink1") - sink2 := feature.MakeRandomK8sName("sink2") - - trigger1 := feature.MakeRandomK8sName("trigger1") - trigger2 := feature.MakeRandomK8sName("trigger2") - - // Construct original cloudevent message - eventType := "type1" - eventSource := "http://source1.com" - eventBody := `{"msg":"e2e-brokerchannel-body"}` - // Construct cloudevent message after transformation - transformedEventType := "type2" - transformedEventSource := "http://source2.com" - transformedBody := `{"msg":"transformed body"}` - - // Construct eventToSend - eventToSend := cloudevents.NewEvent() - eventToSend.SetID(uuid.New().String()) - eventToSend.SetType(eventType) - eventToSend.SetSource(eventSource) - eventToSend.SetData(cloudevents.ApplicationJSON, []byte(eventBody)) - - //Install the broker - brokerName := feature.MakeRandomK8sName("broker") - f.Setup("install broker", broker.Install(brokerName, broker.WithEnvConfig()...)) - f.Setup("broker is ready", broker.IsReady(brokerName)) - f.Setup("broker is addressable", broker.IsAddressable(brokerName)) - - f.Setup("install sink1", eventshub.Install(sink1, - eventshub.ReplyWithTransformedEvent(transformedEventType, transformedEventSource, transformedBody), - eventshub.StartReceiver), - ) - f.Setup("install sink2", eventshub.Install(sink2, eventshub.StartReceiver)) - - // filter1 filters the original events - filter1 := eventingv1.TriggerFilterAttributes{ - "type": eventType, - "source": eventSource, - } - // filter2 filters events after transformation - filter2 := eventingv1.TriggerFilterAttributes{ - "type": transformedEventType, - "source": transformedEventSource, - } - - // Install the trigger1 point to Broker and transform the original events to new events - f.Setup("install trigger1", trigger.Install( - trigger1, - brokerName, - trigger.WithFilter(filter1), - trigger.WithSubscriber(service.AsKReference(sink1), ""), - )) - f.Setup("trigger1 goes ready", trigger.IsReady(trigger1)) - // Install the trigger2 point to Broker to filter all the events - f.Setup("install trigger2", trigger.Install( - trigger2, - brokerName, - trigger.WithFilter(filter2), - trigger.WithSubscriber(service.AsKReference(sink2), ""), - )) - f.Setup("trigger2 goes ready", trigger.IsReady(trigger2)) - - f.Requirement("install source", eventshub.Install( - source, - eventshub.StartSenderToResource(broker.GVR(), brokerName), - eventshub.InputEvent(eventToSend), - )) - - eventMatcher := eventasssert.MatchEvent( - test.HasSource(eventSource), - test.HasType(eventType), - test.HasData([]byte(eventBody)), - ) - transformEventMatcher := eventasssert.MatchEvent( - test.HasSource(transformedEventSource), - test.HasType(transformedEventType), - test.HasData([]byte(transformedBody)), - ) - - f.Stable("Trigger2 has filtered all transformed events"). - Must("delivers original events", - eventasssert.OnStore(sink2).Match(transformEventMatcher).AtLeast(1)) - - f.Stable("Trigger2 has no original events"). - Must("delivers original events", - eventasssert.OnStore(sink2).Match(eventMatcher).Not()) - - return f - -} - func BrokerPreferHeaderCheck() *feature.Feature { f := feature.NewFeatureNamed("Broker PreferHeader Check") @@ -497,7 +216,7 @@ func BrokerPreferHeaderCheck() *feature.Feature { f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) // Point the Trigger subscriber to the sink svc. - cfg := []manifest.CfgFn{trigger.WithSubscriber(service.AsKReference(sink), "")} + cfg := []manifest.CfgFn{trigger.WithSubscriber(svc.AsKReference(sink), "")} // Install the trigger f.Setup("install trigger", trigger.Install(via, brokerName, cfg...)) @@ -558,7 +277,7 @@ func brokerRedeliveryFibonacci(retryNum int32) *feature.Feature { f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) // Point the Trigger subscriber to the sink svc. - cfg := []manifest.CfgFn{trigger.WithSubscriber(service.AsKReference(sink), "")} + cfg := []manifest.CfgFn{trigger.WithSubscriber(svc.AsKReference(sink), "")} // Install the trigger f.Setup("install trigger", trigger.Install(via, brokerName, cfg...)) @@ -613,7 +332,7 @@ func brokerRedeliveryDropN(retryNum int32, dropNum uint) *feature.Feature { f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) // Point the Trigger subscriber to the sink svc. - cfg := []manifest.CfgFn{trigger.WithSubscriber(service.AsKReference(sink), "")} + cfg := []manifest.CfgFn{trigger.WithSubscriber(svc.AsKReference(sink), "")} // Install the trigger f.Setup("install trigger", trigger.Install(via, brokerName, cfg...)) @@ -682,7 +401,7 @@ func brokerSubscriberUnreachable() *feature.Feature { triggerName, brokerName, trigger.WithSubscriber(nil, "http://fake.svc.cluster.local"), - trigger.WithDeadLetterSink(service.AsKReference(sink), ""), + trigger.WithDeadLetterSink(svc.AsKReference(sink), ""), )) f.Setup("trigger goes ready", trigger.IsReady(triggerName)) @@ -737,8 +456,8 @@ func brokerSubscriberErrorNodata() *feature.Feature { f.Setup("install trigger", trigger.Install( triggerName, brokerName, - trigger.WithSubscriber(service.AsKReference(failer), ""), - trigger.WithDeadLetterSink(service.AsKReference(sink), ""), + trigger.WithSubscriber(svc.AsKReference(failer), ""), + trigger.WithDeadLetterSink(svc.AsKReference(sink), ""), )) f.Setup("trigger goes ready", trigger.IsReady(triggerName)) @@ -751,7 +470,7 @@ func brokerSubscriberErrorNodata() *feature.Feature { f.Assert("Receives dls extensions without errordata", assertEnhancedWithKnativeErrorExtensions( sink, func(ctx context.Context) test.EventMatcher { - failerAddress, _ := service.Address(ctx, failer) + failerAddress, _ := svc.Address(ctx, failer) return test.HasExtension("knativeerrordest", failerAddress.String()) }, func(ctx context.Context) test.EventMatcher { @@ -799,8 +518,8 @@ func brokerSubscriberErrorWithdata() *feature.Feature { f.Setup("install trigger", trigger.Install( triggerName, brokerName, - trigger.WithSubscriber(service.AsKReference(failer), ""), - trigger.WithDeadLetterSink(service.AsKReference(sink), ""), + trigger.WithSubscriber(svc.AsKReference(failer), ""), + trigger.WithDeadLetterSink(svc.AsKReference(sink), ""), )) f.Setup("trigger goes ready", trigger.IsReady(triggerName)) @@ -813,7 +532,7 @@ func brokerSubscriberErrorWithdata() *feature.Feature { f.Assert("Receives dls extensions with errordata", assertEnhancedWithKnativeErrorExtensions( sink, func(ctx context.Context) test.EventMatcher { - failerAddress, _ := service.Address(ctx, failer) + failerAddress, _ := svc.Address(ctx, failer) return test.HasExtension("knativeerrordest", failerAddress.String()) }, func(ctx context.Context) test.EventMatcher { @@ -881,7 +600,7 @@ func brokerSubscriberLongMessage() *feature.Feature { f.Setup("install trigger", trigger.Install( triggerName, brokerName, - trigger.WithSubscriber(service.AsKReference(sink), ""), + trigger.WithSubscriber(svc.AsKReference(sink), ""), )) f.Setup("trigger goes ready", trigger.IsReady(triggerName)) @@ -902,6 +621,7 @@ func brokerSubscriberLongMessage() *feature.Feature { /* Following test sends an event to the first sink, Sink1, which will send a long response destined to Sink2. The test will assert that the long response is received by Sink2 + EventSource ---> Broker ---> Trigger1 ---> Sink1(Transformation) ---> Trigger2 --> Sink2 */ @@ -956,7 +676,7 @@ func brokerSubscriberLongResponseMessage() *feature.Feature { f.Setup("install trigger1", trigger.Install( trigger1, brokerName, - trigger.WithSubscriber(service.AsKReference(sink1), ""), + trigger.WithSubscriber(svc.AsKReference(sink1), ""), trigger.WithFilter(map[string]string{"type": eventType1, "source": eventSource1}), )) f.Setup("trigger1 goes ready", trigger.IsReady(trigger1)) @@ -964,7 +684,7 @@ func brokerSubscriberLongResponseMessage() *feature.Feature { f.Setup("install trigger2", trigger.Install( trigger2, brokerName, - trigger.WithSubscriber(service.AsKReference(sink2), ""), + trigger.WithSubscriber(svc.AsKReference(sink2), ""), trigger.WithFilter(map[string]string{"type": eventType2, "source": eventSource2}), )) f.Setup("trigger2 goes ready", trigger.IsReady(trigger2)) @@ -990,43 +710,3 @@ func brokerSubscriberLongResponseMessage() *feature.Feature { return f } - -type eventTestCase struct { - Type string - Source string - Extensions map[string]interface{} -} - -func neweventTestCase(tp, source string) eventTestCase { - return eventTestCase{Type: tp, Source: source} -} - -func neweventTestCaseWithExtensions(tp string, source string, extensions map[string]interface{}) eventTestCase { - return eventTestCase{Type: tp, Source: source, Extensions: extensions} -} - -// toEventMatcher converts the test case to the event matcher -func (tc eventTestCase) toEventMatcher() test.EventMatcher { - var matchers []test.EventMatcher - if tc.Type == eventingv1.TriggerAnyFilter { - matchers = append(matchers, test.ContainsAttributes(spec.Type)) - } else { - matchers = append(matchers, test.HasType(tc.Type)) - } - - if tc.Source == eventingv1.TriggerAnyFilter { - matchers = append(matchers, test.ContainsAttributes(spec.Source)) - } else { - matchers = append(matchers, test.HasSource(tc.Source)) - } - - for k, v := range tc.Extensions { - if v == eventingv1.TriggerAnyFilter { - matchers = append(matchers, test.ContainsExtensions(k)) - } else { - matchers = append(matchers, test.HasExtension(k, v)) - } - } - - return test.AllOf(matchers...) -} diff --git a/vendor/knative.dev/eventing/test/rekt/features/broker/readyness.go b/vendor/knative.dev/eventing/test/rekt/features/broker/readyness.go index bce002cfd0..c2427a2180 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/broker/readyness.go +++ b/vendor/knative.dev/eventing/test/rekt/features/broker/readyness.go @@ -21,7 +21,7 @@ import ( "knative.dev/reconciler-test/pkg/feature" "knative.dev/reconciler-test/pkg/manifest" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" "knative.dev/eventing/test/rekt/resources/broker" "knative.dev/eventing/test/rekt/resources/trigger" @@ -34,10 +34,9 @@ func TriggerGoesReady(name, brokerName string, cfg ...manifest.CfgFn) *feature.F // The test needs a subscriber. sub := feature.MakeRandomK8sName("sub") - f.Setup("install a service", service.Install(sub, - service.WithSelectors(map[string]string{"app": "rekt"}))) + f.Setup("install a service", svc.Install(sub, "app", "rekt")) // Append user-provided cfg to the end, in case they are providing their own subscriber. - cfg = append([]manifest.CfgFn{trigger.WithSubscriber(service.AsKReference(sub), "")}, cfg...) + cfg = append([]manifest.CfgFn{trigger.WithSubscriber(svc.AsKReference(sub), "")}, cfg...) // Install the trigger f.Setup(fmt.Sprintf("install trigger %q", name), trigger.Install(name, brokerName, cfg...)) diff --git a/vendor/knative.dev/eventing/test/rekt/features/broker/source_to_sink.go b/vendor/knative.dev/eventing/test/rekt/features/broker/source_to_sink.go index c3a7d50f73..25634098a6 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/broker/source_to_sink.go +++ b/vendor/knative.dev/eventing/test/rekt/features/broker/source_to_sink.go @@ -17,16 +17,20 @@ limitations under the License. package broker import ( + "context" + "fmt" "time" "github.com/google/uuid" + "knative.dev/reconciler-test/pkg/environment" "knative.dev/reconciler-test/pkg/eventshub" "knative.dev/reconciler-test/pkg/feature" "knative.dev/reconciler-test/pkg/manifest" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" "knative.dev/eventing/test/rekt/resources/broker" "knative.dev/eventing/test/rekt/resources/delivery" + "knative.dev/eventing/test/rekt/resources/flaker" "knative.dev/eventing/test/rekt/resources/trigger" . "github.com/cloudevents/sdk-go/v2/test" @@ -46,7 +50,7 @@ func SourceToSink(brokerName string) *feature.Feature { f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) // Point the Trigger subscriber to the sink svc. - cfg := []manifest.CfgFn{trigger.WithSubscriber(service.AsKReference(sink), "")} + cfg := []manifest.CfgFn{trigger.WithSubscriber(svc.AsKReference(sink), "")} // Install the trigger f.Setup("install trigger", trigger.Install(via, brokerName, cfg...)) @@ -82,7 +86,7 @@ func SourceToSinkWithDLQ() *feature.Feature { f.Setup("install dead letter sink service", eventshub.Install(dls, eventshub.StartReceiver)) - brokerConfig := append(broker.WithEnvConfig(), delivery.WithDeadLetterSink(service.AsKReference(dls), "")) + brokerConfig := append(broker.WithEnvConfig(), delivery.WithDeadLetterSink(svc.AsKReference(dls), "")) f.Setup("install broker", broker.Install(brokerName, brokerConfig...)) f.Setup("Broker is ready", broker.IsReady(brokerName)) f.Setup("install trigger", trigger.Install(triggerName, brokerName, trigger.WithSubscriber(nil, "bad://uri"))) @@ -113,6 +117,7 @@ func SourceToSinkWithDLQ() *feature.Feature { func SourceToSinkWithFlakyDLQ(brokerName string) *feature.Feature { source := feature.MakeRandomK8sName("source") sink := feature.MakeRandomK8sName("sink") + flake := feature.MakeRandomK8sName("flake") dlq := feature.MakeRandomK8sName("dlq") via := feature.MakeRandomK8sName("via") @@ -120,10 +125,16 @@ func SourceToSinkWithFlakyDLQ(brokerName string) *feature.Feature { f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) + f.Setup("install flake", func(ctx context.Context, t feature.T) { + env := environment.FromContext(ctx) + u := fmt.Sprintf("%s.%s.svc.cluster.local", sink, env.Namespace()) // HACK HACK HACK, could replace with SinkBinding. + flaker.Install(flake, u)(ctx, t) + }) + f.Setup("install dlq", eventshub.Install(dlq, eventshub.StartReceiver)) f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver, eventshub.DropFirstN(2))) - f.Setup("update broker with DLQ", broker.Install(brokerName, broker.WithDeadLetterSink(service.AsKReference(dlq), ""))) - f.Setup("install trigger", trigger.Install(via, brokerName, trigger.WithSubscriber(service.AsKReference(sink), ""))) + f.Setup("update broker with DLQ", broker.Install(brokerName, broker.WithDeadLetterSink(svc.AsKReference(dlq), ""))) + f.Setup("install trigger", trigger.Install(via, brokerName, trigger.WithSubscriber(svc.AsKReference(sink), ""))) f.Setup("trigger goes ready", trigger.IsReady(via)) f.Setup("broker goes ready", broker.IsReady(via)) diff --git a/vendor/knative.dev/eventing/test/rekt/features/channel/control_plane.go b/vendor/knative.dev/eventing/test/rekt/features/channel/control_plane.go index f6c19b5f15..4abcab91f6 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/channel/control_plane.go +++ b/vendor/knative.dev/eventing/test/rekt/features/channel/control_plane.go @@ -27,7 +27,7 @@ import ( "knative.dev/pkg/apis/duck" "knative.dev/reconciler-test/pkg/environment" "knative.dev/reconciler-test/pkg/feature" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" duckv1 "knative.dev/eventing/pkg/apis/duck/v1" "knative.dev/eventing/pkg/apis/messaging" @@ -106,9 +106,8 @@ func ControlPlaneChannel(channelName string) *feature.Feature { cName := feature.MakeRandomK8sName("channel") sink := feature.MakeRandomK8sName("sink") - f.Setup("install a service", service.Install(sink, - service.WithSelectors(map[string]string{"app": "rekt"}))) - f.Setup("update Channel", channel_impl.Install(cName, delivery.WithDeadLetterSink(service.AsKReference(sink), ""))) + f.Setup("install a service", svc.Install(sink, "app", "rekt")) + f.Setup("update Channel", channel_impl.Install(cName, delivery.WithDeadLetterSink(svc.AsKReference(sink), ""))) f.Setup("Channel goes ready", channel_impl.IsReady(cName)) f.Setup("Channel is addressable", channel_impl.IsAddressable(cName)) diff --git a/vendor/knative.dev/eventing/test/rekt/features/channel/features.go b/vendor/knative.dev/eventing/test/rekt/features/channel/features.go index 0384403ac2..75d2da1340 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/channel/features.go +++ b/vendor/knative.dev/eventing/test/rekt/features/channel/features.go @@ -30,7 +30,7 @@ import ( "knative.dev/reconciler-test/pkg/eventshub/assert" "knative.dev/reconciler-test/pkg/feature" "knative.dev/reconciler-test/pkg/manifest" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" eventasssert "knative.dev/reconciler-test/pkg/eventshub/assert" @@ -67,7 +67,7 @@ func ChannelChain(length int, createSubscriberFn func(ref *duckv1.KReference, ur // install the final connection to the sink f.Setup("install sink subscription", subscription.Install(sub, subscription.WithChannel(channel_impl.AsRef(channels[i])), - createSubscriberFn(service.AsKReference(sink), ""), + createSubscriberFn(svc.AsKReference(sink), ""), )) } else { f.Setup("install subscription", subscription.Install(sub, @@ -93,10 +93,10 @@ func DeadLetterSink(createSubscriberFn func(ref *duckv1.KReference, uri string) f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) f.Setup("install failing receiver", eventshub.Install(failer, eventshub.StartReceiver, eventshub.DropFirstN(1))) - f.Setup("install channel", channel_impl.Install(name, delivery.WithDeadLetterSink(service.AsKReference(sink), ""))) + f.Setup("install channel", channel_impl.Install(name, delivery.WithDeadLetterSink(svc.AsKReference(sink), ""))) f.Setup("install subscription", subscription.Install(sub, subscription.WithChannel(channel_impl.AsRef(name)), - createSubscriberFn(service.AsKReference(failer), ""), + createSubscriberFn(svc.AsKReference(failer), ""), )) f.Setup("channel is ready", channel_impl.IsReady(name)) f.Setup("subscription is ready", subscription.IsReady(sub)) @@ -125,11 +125,11 @@ func DeadLetterSinkGenericChannel(createSubscriberFn func(ref *duckv1.KReference f.Setup("install failing receiver", eventshub.Install(failer, eventshub.StartReceiver, eventshub.DropFirstN(1))) f.Setup("install channel", channel.Install(name, channel.WithTemplate(), - delivery.WithDeadLetterSink(service.AsKReference(sink), "")), + delivery.WithDeadLetterSink(svc.AsKReference(sink), "")), ) f.Setup("install subscription", subscription.Install(sub, subscription.WithChannel(channel.AsRef(name)), - createSubscriberFn(service.AsKReference(failer), ""), + createSubscriberFn(svc.AsKReference(failer), ""), )) f.Setup("channel is ready", channel.IsReady(name)) f.Setup("subscription is ready", subscription.IsReady(sub)) @@ -165,7 +165,7 @@ func AsDeadLetterSink(createSubscriberFn func(ref *duckv1.KReference, uri string ) f.Setup("install subscription", subscription.Install(feature.MakeRandomK8sName("subscription"), subscription.WithChannel(channel.AsRef(name)), - createSubscriberFn(service.AsKReference(failer), ""), + createSubscriberFn(svc.AsKReference(failer), ""), )) f.Setup("install DLS channel", channel.Install(dls, @@ -173,7 +173,7 @@ func AsDeadLetterSink(createSubscriberFn func(ref *duckv1.KReference, uri string )) f.Setup("install DLS subscription", subscription.Install(feature.MakeRandomK8sName("dls-subscription"), subscription.WithChannel(channel.AsRef(dls)), - createSubscriberFn(service.AsKReference(sink), ""), + createSubscriberFn(svc.AsKReference(sink), ""), )) f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) @@ -291,7 +291,7 @@ func ChannelPreferHeaderCheck(createSubscriberFn func(ref *duckv1.KReference, ur )) f.Setup("install subscription", subscription.Install(sub, subscription.WithChannel(channel.AsRef(channelName)), - createSubscriberFn(service.AsKReference(sink), ""), + createSubscriberFn(svc.AsKReference(sink), ""), )) f.Setup("subscription is ready", subscription.IsReady(sub)) @@ -336,7 +336,7 @@ func channelSubscriberUnreachable(createSubscriberFn func(ref *duckv1.KReference f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) - f.Setup("install channel", channel_impl.Install(channelName, delivery.WithDeadLetterSink(service.AsKReference(sink), ""))) + f.Setup("install channel", channel_impl.Install(channelName, delivery.WithDeadLetterSink(svc.AsKReference(sink), ""))) f.Setup("install subscription", subscription.Install(sub, subscription.WithChannel(channel_impl.AsRef(channelName)), @@ -381,11 +381,11 @@ func channelSubscriberReturnedErrorNoData(createSubscriberFn func(ref *duckv1.KR eventshub.DropFirstN(1), eventshub.DropEventsResponseCode(422), )) - f.Setup("install channel", channel_impl.Install(channelName, delivery.WithDeadLetterSink(service.AsKReference(sink), ""))) + f.Setup("install channel", channel_impl.Install(channelName, delivery.WithDeadLetterSink(svc.AsKReference(sink), ""))) f.Setup("install subscription", subscription.Install(sub, subscription.WithChannel(channel_impl.AsRef(channelName)), - createSubscriberFn(service.AsKReference(failer), ""), + createSubscriberFn(svc.AsKReference(failer), ""), )) f.Setup("channel is ready", channel_impl.IsReady(channelName)) f.Setup("channel is addressable", channel_impl.IsAddressable(channelName)) @@ -402,7 +402,7 @@ func channelSubscriberReturnedErrorNoData(createSubscriberFn func(ref *duckv1.KR f.Assert("Receives dls extensions without errordata", assertEnhancedWithKnativeErrorExtensions( sink, func(ctx context.Context) test.EventMatcher { - failerAddress, _ := service.Address(ctx, failer) + failerAddress, _ := svc.Address(ctx, failer) return test.HasExtension("knativeerrordest", failerAddress.String()) }, func(ctx context.Context) test.EventMatcher { @@ -434,10 +434,10 @@ func channelSubscriberReturnedErrorWithData(createSubscriberFn func(ref *duckv1. eventshub.DropEventsResponseCode(422), eventshub.DropEventsResponseBody(errorData), )) - f.Setup("install channel", channel_impl.Install(channelName, delivery.WithDeadLetterSink(service.AsKReference(sink), ""))) + f.Setup("install channel", channel_impl.Install(channelName, delivery.WithDeadLetterSink(svc.AsKReference(sink), ""))) f.Setup("install subscription", subscription.Install(sub, subscription.WithChannel(channel_impl.AsRef(channelName)), - createSubscriberFn(service.AsKReference(failer), ""), + createSubscriberFn(svc.AsKReference(failer), ""), )) f.Setup("channel is ready", channel_impl.IsReady(channelName)) f.Setup("channel is addressable", channel_impl.IsAddressable(channelName)) @@ -454,7 +454,7 @@ func channelSubscriberReturnedErrorWithData(createSubscriberFn func(ref *duckv1. f.Assert("Receives dls extensions with errordata Base64encoding", assertEnhancedWithKnativeErrorExtensions( sink, func(ctx context.Context) test.EventMatcher { - failerAddress, _ := service.Address(ctx, failer) + failerAddress, _ := svc.Address(ctx, failer) return test.HasExtension("knativeerrordest", failerAddress.String()) }, func(ctx context.Context) test.EventMatcher { diff --git a/vendor/knative.dev/eventing/test/rekt/features/trigger/control_plane.go b/vendor/knative.dev/eventing/test/rekt/features/trigger/control_plane.go index bd3c70be24..1aacae7387 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/trigger/control_plane.go +++ b/vendor/knative.dev/eventing/test/rekt/features/trigger/control_plane.go @@ -24,7 +24,7 @@ import ( eventingv1 "knative.dev/eventing/pkg/apis/eventing/v1" triggerresources "knative.dev/eventing/test/rekt/resources/trigger" "knative.dev/reconciler-test/pkg/feature" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" ) func Defaulting() *feature.FeatureSet { @@ -44,7 +44,7 @@ func Defaulting_Filter() *feature.Feature { resourceName := feature.MakeRandomK8sName("trigger") - withSubscriber := triggerresources.WithSubscriber(service.AsKReference("sub"), "") + withSubscriber := triggerresources.WithSubscriber(svc.AsKReference("sub"), "") f.Setup("Set Trigger name", SetTriggerName(resourceName)) f.Setup("Create a Trigger with empty spec.filter", @@ -61,7 +61,7 @@ func Defaulting_SubscriberNamespace() *feature.Feature { resourceName := feature.MakeRandomK8sName("trigger") - withSubscriber := triggerresources.WithSubscriber(service.AsKReference("sub"), "") + withSubscriber := triggerresources.WithSubscriber(svc.AsKReference("sub"), "") f.Setup("Set Trigger name", SetTriggerName(resourceName)) f.Setup("Create a Trigger with empty subscriber namespace", diff --git a/vendor/knative.dev/eventing/test/rekt/features/trigger/feature.go b/vendor/knative.dev/eventing/test/rekt/features/trigger/feature.go index 8c853b47d0..c7a03e7355 100644 --- a/vendor/knative.dev/eventing/test/rekt/features/trigger/feature.go +++ b/vendor/knative.dev/eventing/test/rekt/features/trigger/feature.go @@ -24,7 +24,7 @@ import ( "knative.dev/reconciler-test/pkg/eventshub/assert" "knative.dev/reconciler-test/pkg/feature" "knative.dev/reconciler-test/pkg/manifest" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/resources/svc" "knative.dev/eventing/test/rekt/resources/broker" "knative.dev/eventing/test/rekt/resources/pingsource" @@ -53,7 +53,7 @@ func TriggerDependencyAnnotation() *feature.Feature { // Add the annotation to trigger and point the Trigger subscriber to the sink svc. f.Setup("install sink", eventshub.Install(sink, eventshub.StartReceiver)) cfg := []manifest.CfgFn{ - trigger.WithSubscriber(service.AsKReference(sink), ""), + trigger.WithSubscriber(svc.AsKReference(sink), ""), trigger.WithAnnotations(annotations), } diff --git a/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.go b/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.go index affe5b7801..ceb0a474e8 100644 --- a/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.go +++ b/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.go @@ -22,7 +22,6 @@ import ( "time" "k8s.io/apimachinery/pkg/runtime/schema" - "knative.dev/eventing/test/rekt/resources/source" "knative.dev/reconciler-test/pkg/environment" @@ -53,10 +52,6 @@ func Install(name string, opts ...manifest.CfgFn) feature.StepFn { } return func(ctx context.Context, t feature.T) { - if ic := environment.GetIstioConfig(ctx); ic.Enabled { - manifest.WithIstioPodAnnotations(cfg) - } - if err := registerImage(ctx); err != nil { t.Fatal(err) } diff --git a/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.yaml b/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.yaml index d4d6803d66..7482dd1ef6 100644 --- a/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.yaml +++ b/vendor/knative.dev/eventing/test/rekt/resources/containersource/containersource.yaml @@ -39,13 +39,6 @@ spec: uri: {{ .sink.uri }} {{ end }} template: - {{ if .podannotations }} - metadata: - annotations: - {{ range $key, $value := .podannotations }} - {{ $key }}: "{{ $value }}" - {{ end }} - {{ end }} spec: containers: - name: heartbeats diff --git a/vendor/knative.dev/eventing/test/rekt/resources/flaker/flaker.go b/vendor/knative.dev/eventing/test/rekt/resources/flaker/flaker.go new file mode 100644 index 0000000000..4b6f8d4c64 --- /dev/null +++ b/vendor/knative.dev/eventing/test/rekt/resources/flaker/flaker.go @@ -0,0 +1,64 @@ +/* +Copyright 2021 The Knative 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 flaker + +import ( + "context" + "embed" + + duckv1 "knative.dev/pkg/apis/duck/v1" + "knative.dev/reconciler-test/pkg/environment" + "knative.dev/reconciler-test/pkg/feature" + "knative.dev/reconciler-test/pkg/manifest" +) + +//go:embed *.yaml +var yaml embed.FS + +// Install +func Install(name, sink string) feature.StepFn { + cfg := map[string]interface{}{ + "name": name, + "sink": sink, + } + + return func(ctx context.Context, t feature.T) { + if err := registerImage(ctx); err != nil { + t.Fatal(err) + } + manifest.PodSecurityCfgFn(ctx, t)(cfg) + if _, err := manifest.InstallYamlFS(ctx, yaml, cfg); err != nil { + t.Fatal(err) + } + } +} + +// AsRef returns a KRef for a Service without namespace. +func AsRef(name string) *duckv1.KReference { + return &duckv1.KReference{ + Kind: "Service", + APIVersion: "v1", + Name: name, + } +} + +func registerImage(ctx context.Context) error { + im := manifest.ImagesFromFS(ctx, yaml) + reg := environment.RegisterPackage(im...) + _, err := reg(ctx, environment.FromContext(ctx)) + return err +} diff --git a/vendor/knative.dev/eventing/test/rekt/resources/flaker/flaker.yaml b/vendor/knative.dev/eventing/test/rekt/resources/flaker/flaker.yaml new file mode 100644 index 0000000000..69aba2123b --- /dev/null +++ b/vendor/knative.dev/eventing/test/rekt/resources/flaker/flaker.yaml @@ -0,0 +1,66 @@ +# Copyright 2021 The Knative 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. + +apiVersion: v1 +kind: Pod +metadata: + name: {{ .name }} + namespace: {{ .namespace }} + labels: + app: flaker-{{ .name }} +spec: + {{ if .podSecurityContext }} + securityContext: + runAsNonRoot: {{ .podSecurityContext.runAsNonRoot }} + seccompProfile: + type: {{ .podSecurityContext.seccompProfile.type }} + {{ end }} + restartPolicy: "Never" + containers: + - name: flaker + image: ko://knative.dev/eventing/test/test_images/event-flaker + imagePullPolicy: "IfNotPresent" + {{ if .containerSecurityContext }} + securityContext: + capabilities: + {{ if .containerSecurityContext.capabilities.drop }} + drop: + {{ range $_, $value := .containerSecurityContext.capabilities.drop }} + - {{ $value }} + {{ end }} + {{ end }} + {{ if .containerSecurityContext.capabilities.add }} + add: + {{ range $_, $value := .containerSecurityContext.capabilities.add }} + - {{ $value }} + {{ end }} + {{ end }} + allowPrivilegeEscalation: {{ .containerSecurityContext.allowPrivilegeEscalation }} + {{ end }} + env: + - name: "K_SINK" + value: "{{ .sink }}" +--- +apiVersion: v1 +kind: Service +metadata: + name: {{ .name }} + namespace: {{ .namespace }} +spec: + selector: + app: flaker-{{ .name }} + ports: + - protocol: TCP + port: 80 + targetPort: 8080 diff --git a/vendor/knative.dev/eventing/test/rekt/resources/svc/service.go b/vendor/knative.dev/eventing/test/rekt/resources/svc/service.go index 8db20bebd7..f453045d83 100644 --- a/vendor/knative.dev/eventing/test/rekt/resources/svc/service.go +++ b/vendor/knative.dev/eventing/test/rekt/resources/svc/service.go @@ -17,37 +17,72 @@ limitations under the License. package svc import ( - v1 "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/util/intstr" + "context" + "embed" + + "k8s.io/apimachinery/pkg/runtime/schema" + "knative.dev/pkg/apis" + duckv1 "knative.dev/pkg/apis/duck/v1" + "knative.dev/pkg/tracker" "knative.dev/reconciler-test/pkg/feature" - "knative.dev/reconciler-test/pkg/resources/service" + "knative.dev/reconciler-test/pkg/k8s" + "knative.dev/reconciler-test/pkg/manifest" + "knative.dev/reconciler-test/resources/svc" ) -// Deprecated, use reconciler-test/pkg/resources/service -var Gvr = service.GVR +//go:embed *.yaml +var yaml embed.FS + +// Deprecated, use reconciler-test/resources/svc +func Gvr() schema.GroupVersionResource { + return schema.GroupVersionResource{Group: "", Version: "v1", Resource: "services"} +} // Install will create a Service resource mapping :80 to :8080 on the provided // selector for pods. -// Deprecated, use reconciler-test/pkg/resources/service +// Deprecated, use reconciler-test/resources/svc func Install(name, selectorKey, selectorValue string) feature.StepFn { - return service.Install(name, - service.WithSelectors(map[string]string{selectorKey: selectorValue}), - service.WithPorts([]v1.ServicePort{{ - Port: 80, - TargetPort: intstr.FromInt(8080), - }})) + cfg := map[string]interface{}{ + "name": name, + "selectorKey": selectorKey, + "selectorValue": selectorValue, + } + + return func(ctx context.Context, t feature.T) { + if _, err := manifest.InstallYamlFS(ctx, yaml, cfg); err != nil { + t.Fatal(err) + } + } } // AsRef returns a KRef for a Service without namespace. -// Deprecated, use reconciler-test/pkg/resources/service -var AsRef = service.AsKReference +// Deprecated, use reconciler-test/resources/svc +func AsRef(name string) *duckv1.KReference { + return &duckv1.KReference{ + Kind: "Service", + Name: name, + APIVersion: "v1", + } +} -// Deprecated, use reconciler-test/pkg/resources/service -var AsTrackerReference = service.AsTrackerReference +// Deprecated, use reconciler-test/resources/svc +func AsTrackerReference(name string) *tracker.Reference { + return &tracker.Reference{ + Kind: "Service", + Name: name, + APIVersion: "v1", + } +} -// Deprecated, use reconciler-test/pkg/resources/service -var AsDestinationRef = service.AsDestinationRef +// Deprecated, use reconciler-test/resources/svc +func AsDestinationRef(name string) *duckv1.Destination { + return &duckv1.Destination{ + Ref: AsRef(name), + } +} // Address -// Deprecated, use reconciler-test/pkg/resources/service -var Address = service.Address +// Deprecated, use reconciler-test/resources/svc +func Address(ctx context.Context, name string) (*apis.URL, error) { + return k8s.Address(ctx, svc.GVR(), name) +} diff --git a/vendor/knative.dev/eventing/test/rekt/resources/svc/service.yaml b/vendor/knative.dev/eventing/test/rekt/resources/svc/service.yaml new file mode 100644 index 0000000000..e61cd1bfb6 --- /dev/null +++ b/vendor/knative.dev/eventing/test/rekt/resources/svc/service.yaml @@ -0,0 +1,26 @@ +# Copyright 2020 The Knative 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. + +apiVersion: v1 +kind: Service +metadata: + name: {{ .name }} + namespace: {{ .namespace }} +spec: + selector: + {{ .selectorKey }}: {{ .selectorValue }} + ports: + - protocol: TCP + port: 80 + targetPort: 8080 diff --git a/vendor/knative.dev/eventing/test/upgrade/prober/verify.go b/vendor/knative.dev/eventing/test/upgrade/prober/verify.go index b855826aaf..55dc12d38b 100644 --- a/vendor/knative.dev/eventing/test/upgrade/prober/verify.go +++ b/vendor/knative.dev/eventing/test/upgrade/prober/verify.go @@ -24,6 +24,7 @@ import ( "path/filepath" "regexp" "strings" + "sync" "time" "go.uber.org/zap" @@ -51,6 +52,8 @@ const ( stepEventMsgPattern = "event #([0-9]+).*" ) +var lock sync.Mutex + // Verify will verify prober state after finished has been sent. func (p *prober) Verify() (eventErrs []error, eventsSent int) { var report *receiver.Report @@ -58,6 +61,11 @@ func (p *prober) Verify() (eventErrs []error, eventsSent int) { if err := zipkin.SetupZipkinTracingFromConfigTracing(p.config.Ctx, p.client.Kube, p.client.T.Logf, system.Namespace()); err != nil { p.log.Warnf("Failed to setup Zipkin tracing. Traces for events won't be available.") + } else { + lock.Lock() + // Required for proper cleanup. + zipkin.ZipkinTracingEnabled = true + lock.Unlock() } p.log.Info("Waiting for complete report from receiver...") start := time.Now() diff --git a/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go b/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go index 83e746a001..bdcb994fac 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go +++ b/vendor/knative.dev/pkg/apis/duck/v1/addressable_types.go @@ -38,7 +38,16 @@ import ( // typically stored in the object's `status`, as this information may // be generated by the controller. type Addressable struct { + // Name is the name of the address. + // +optional + Name *string `json:"name,omitempty"` + URL *apis.URL `json:"url,omitempty"` + + // CACerts is the Certification Authority (CA) certificates in PEM format + // according to https://www.rfc-editor.org/rfc/rfc7468. + // +optional + CACerts *string `json:"CACerts,omitempty"` } var ( @@ -62,7 +71,15 @@ type AddressableType struct { // AddressStatus shows how we expect folks to embed Addressable in // their Status field. type AddressStatus struct { + // Address is a single Addressable address. + // If Addresses is present, Address will be ignored by clients. + // +optional Address *Addressable `json:"address,omitempty"` + + // Addresses is a list of addresses for different protocols (HTTP and HTTPS) + // If Addresses is present, Address must be ignored by clients. + // +optional + Addresses []Addressable `json:"addresses,omitempty"` } // Verify AddressableType resources meet duck contracts. @@ -89,9 +106,11 @@ func (a *Addressable) ConvertFrom(ctx context.Context, from apis.Convertible) er // Populate implements duck.Populatable func (t *AddressableType) Populate() { + name := "http" t.Status = AddressStatus{ - &Addressable{ + Address: &Addressable{ // Populate ALL fields + Name: &name, URL: &apis.URL{ Scheme: "http", Host: "foo.com", diff --git a/vendor/knative.dev/pkg/apis/duck/v1/destination.go b/vendor/knative.dev/pkg/apis/duck/v1/destination.go index c895e6d29f..15638f4018 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1/destination.go +++ b/vendor/knative.dev/pkg/apis/duck/v1/destination.go @@ -31,6 +31,13 @@ type Destination struct { // URI can be an absolute URL(non-empty scheme and non-empty host) pointing to the target or a relative URI. Relative URIs will be resolved using the base URI retrieved from Ref. // +optional URI *apis.URL `json:"uri,omitempty"` + + // CACerts are Certification Authority (CA) certificates in PEM format + // according to https://www.rfc-editor.org/rfc/rfc7468. + // If set, these CAs are appended to the set of CAs provided + // by the Addressable target, if any. + // +optional + CACerts *string `json:"CACerts,omitempty"` } // Validate the Destination has all the necessary fields and check the diff --git a/vendor/knative.dev/pkg/apis/duck/v1/knative_reference.go b/vendor/knative.dev/pkg/apis/duck/v1/knative_reference.go index a0b169d6f8..c723c147a9 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1/knative_reference.go +++ b/vendor/knative.dev/pkg/apis/duck/v1/knative_reference.go @@ -49,6 +49,10 @@ type KReference struct { // Note: This API is EXPERIMENTAL and might break anytime. For more details: https://github.com/knative/eventing/issues/5086 // +optional Group string `json:"group,omitempty"` + + // Address points to a specific Address Name. + // +optional + Address *string `json:"address,omitempty"` } func (kr *KReference) Validate(ctx context.Context) *apis.FieldError { diff --git a/vendor/knative.dev/pkg/apis/duck/v1/zz_generated.deepcopy.go b/vendor/knative.dev/pkg/apis/duck/v1/zz_generated.deepcopy.go index 96638e5799..83cccfd3b8 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1/zz_generated.deepcopy.go +++ b/vendor/knative.dev/pkg/apis/duck/v1/zz_generated.deepcopy.go @@ -34,6 +34,13 @@ func (in *AddressStatus) DeepCopyInto(out *AddressStatus) { *out = new(Addressable) (*in).DeepCopyInto(*out) } + if in.Addresses != nil { + in, out := &in.Addresses, &out.Addresses + *out = make([]Addressable, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } return } @@ -50,11 +57,21 @@ func (in *AddressStatus) DeepCopy() *AddressStatus { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Addressable) DeepCopyInto(out *Addressable) { *out = *in + if in.Name != nil { + in, out := &in.Name, &out.Name + *out = new(string) + **out = **in + } if in.URL != nil { in, out := &in.URL, &out.URL *out = new(apis.URL) (*in).DeepCopyInto(*out) } + if in.CACerts != nil { + in, out := &in.CACerts, &out.CACerts + *out = new(string) + **out = **in + } return } @@ -332,13 +349,18 @@ func (in *Destination) DeepCopyInto(out *Destination) { if in.Ref != nil { in, out := &in.Ref, &out.Ref *out = new(KReference) - **out = **in + (*in).DeepCopyInto(*out) } if in.URI != nil { in, out := &in.URI, &out.URI *out = new(apis.URL) (*in).DeepCopyInto(*out) } + if in.CACerts != nil { + in, out := &in.CACerts, &out.CACerts + *out = new(string) + **out = **in + } return } @@ -355,6 +377,11 @@ func (in *Destination) DeepCopy() *Destination { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *KReference) DeepCopyInto(out *KReference) { *out = *in + if in.Address != nil { + in, out := &in.Address, &out.Address + *out = new(string) + **out = **in + } return } diff --git a/vendor/knative.dev/pkg/apis/duck/v1alpha1/addressable_types.go b/vendor/knative.dev/pkg/apis/duck/v1alpha1/addressable_types.go index 328246f6f6..e0399f55d5 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1alpha1/addressable_types.go +++ b/vendor/knative.dev/pkg/apis/duck/v1alpha1/addressable_types.go @@ -66,7 +66,15 @@ type AddressableType struct { // AddressStatus shows how we expect folks to embed Addressable in // their Status field. type AddressStatus struct { + // Address is a single Addressable address. + // If Addresses is present, Address will be ignored by clients. + // +optional Address *Addressable `json:"address,omitempty"` + + // Addresses is a list of addresses for different protocols (HTTP and HTTPS) + // If Addresses is present, Address must be ignored by clients. + // +optional + Addresses []Addressable `json:"addresses,omitempty"` } var ( @@ -123,10 +131,12 @@ func (a *Addressable) ConvertFrom(ctx context.Context, from apis.Convertible) er // Populate implements duck.Populatable func (t *AddressableType) Populate() { + name := "http" t.Status = AddressStatus{ - &Addressable{ + Address: &Addressable{ // Populate ALL fields Addressable: v1beta1.Addressable{ + Name: &name, URL: &apis.URL{ Scheme: "http", Host: "foo.bar.svc.cluster.local", diff --git a/vendor/knative.dev/pkg/apis/duck/v1alpha1/zz_generated.deepcopy.go b/vendor/knative.dev/pkg/apis/duck/v1alpha1/zz_generated.deepcopy.go index c845923b19..4c9d622365 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1alpha1/zz_generated.deepcopy.go +++ b/vendor/knative.dev/pkg/apis/duck/v1alpha1/zz_generated.deepcopy.go @@ -33,6 +33,13 @@ func (in *AddressStatus) DeepCopyInto(out *AddressStatus) { *out = new(Addressable) (*in).DeepCopyInto(*out) } + if in.Addresses != nil { + in, out := &in.Addresses, &out.Addresses + *out = make([]Addressable, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } return } diff --git a/vendor/knative.dev/pkg/apis/duck/v1beta1/addressable_types.go b/vendor/knative.dev/pkg/apis/duck/v1beta1/addressable_types.go index ba7bbc85d8..57f310e52a 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1beta1/addressable_types.go +++ b/vendor/knative.dev/pkg/apis/duck/v1beta1/addressable_types.go @@ -37,7 +37,16 @@ import ( // typically stored in the object's `status`, as this information may // be generated by the controller. type Addressable struct { + // Name is the name of the address. + // +optional + Name *string `json:"name,omitempty"` + URL *apis.URL `json:"url,omitempty"` + + // CACerts is the Certification Authority (CA) certificates in PEM format + // according to https://www.rfc-editor.org/rfc/rfc7468. + // +optional + CACerts *string `json:"CACerts,omitempty"` } var ( @@ -64,7 +73,15 @@ type AddressableType struct { // AddressStatus shows how we expect folks to embed Addressable in // their Status field. type AddressStatus struct { + // Address is a single Addressable address. + // If Addresses is present, Address will be ignored by clients. + // +optional Address *Addressable `json:"address,omitempty"` + + // Addresses is a list of addresses for different protocols (HTTP and HTTPS) + // If Addresses is present, Address must be ignored by clients. + // +optional + Addresses []Addressable `json:"addresses,omitempty"` } // Verify AddressableType resources meet duck contracts. @@ -102,9 +119,11 @@ func (a *Addressable) ConvertFrom(ctx context.Context, from apis.Convertible) er // Populate implements duck.Populatable func (t *AddressableType) Populate() { + name := "http" t.Status = AddressStatus{ - &Addressable{ + Address: &Addressable{ // Populate ALL fields + Name: &name, URL: &apis.URL{ Scheme: "http", Host: "foo.com", diff --git a/vendor/knative.dev/pkg/apis/duck/v1beta1/destination.go b/vendor/knative.dev/pkg/apis/duck/v1beta1/destination.go index 4e369b8721..4c361d7c1c 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1beta1/destination.go +++ b/vendor/knative.dev/pkg/apis/duck/v1beta1/destination.go @@ -44,6 +44,13 @@ type Destination struct { // URI can be an absolute URL(non-empty scheme and non-empty host) pointing to the target or a relative URI. Relative URIs will be resolved using the base URI retrieved from Ref. // +optional URI *apis.URL `json:"uri,omitempty"` + + // CACerts are Certification Authority (CA) certificates in PEM format + // according to https://www.rfc-editor.org/rfc/rfc7468. + // If set, these CAs are appended to the set of CAs provided + // by the Addressable target, if any. + // +optional + CACerts *string `json:"CACerts,omitempty"` } func (dest *Destination) Validate(ctx context.Context) *apis.FieldError { diff --git a/vendor/knative.dev/pkg/apis/duck/v1beta1/zz_generated.deepcopy.go b/vendor/knative.dev/pkg/apis/duck/v1beta1/zz_generated.deepcopy.go index 743081b012..6ba145f3eb 100644 --- a/vendor/knative.dev/pkg/apis/duck/v1beta1/zz_generated.deepcopy.go +++ b/vendor/knative.dev/pkg/apis/duck/v1beta1/zz_generated.deepcopy.go @@ -35,6 +35,13 @@ func (in *AddressStatus) DeepCopyInto(out *AddressStatus) { *out = new(Addressable) (*in).DeepCopyInto(*out) } + if in.Addresses != nil { + in, out := &in.Addresses, &out.Addresses + *out = make([]Addressable, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } return } @@ -51,11 +58,21 @@ func (in *AddressStatus) DeepCopy() *AddressStatus { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *Addressable) DeepCopyInto(out *Addressable) { *out = *in + if in.Name != nil { + in, out := &in.Name, &out.Name + *out = new(string) + **out = **in + } if in.URL != nil { in, out := &in.URL, &out.URL *out = new(apis.URL) (*in).DeepCopyInto(*out) } + if in.CACerts != nil { + in, out := &in.CACerts, &out.CACerts + *out = new(string) + **out = **in + } return } @@ -264,6 +281,11 @@ func (in *Destination) DeepCopyInto(out *Destination) { *out = new(apis.URL) (*in).DeepCopyInto(*out) } + if in.CACerts != nil { + in, out := &in.CACerts, &out.CACerts + *out = new(string) + **out = **in + } return } diff --git a/vendor/knative.dev/pkg/injection/health_check.go b/vendor/knative.dev/pkg/injection/health_check.go index 2899c7e35b..d4eb7fd467 100644 --- a/vendor/knative.dev/pkg/injection/health_check.go +++ b/vendor/knative.dev/pkg/injection/health_check.go @@ -40,7 +40,7 @@ func ServeHealthProbes(ctx context.Context, port int) error { }() // start the web server on port and accept requests - logger.Infof("Probes server listening on port %s", port) + logger.Infof("Probes server listening on port %d", port) if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { return err } diff --git a/vendor/knative.dev/pkg/metrics/config.go b/vendor/knative.dev/pkg/metrics/config.go index 3fe3c1737d..ce5e7f875f 100644 --- a/vendor/knative.dev/pkg/metrics/config.go +++ b/vendor/knative.dev/pkg/metrics/config.go @@ -41,19 +41,21 @@ const ( DomainEnv = "METRICS_DOMAIN" // The following keys are used to configure metrics reporting. - // See https://github.com/knative/serving/blob/main/config/config-observability.yaml + // See https://github.com/knative/serving/blob/main/config/core/configmaps/observability.yaml // for details. collectorAddressKey = "metrics.opencensus-address" collectorSecureKey = "metrics.opencensus-require-tls" reportingPeriodKey = "metrics.reporting-period-seconds" - defaultBackendEnvName = "DEFAULT_METRICS_BACKEND" - defaultPrometheusPort = 9090 - maxPrometheusPort = 65535 - minPrometheusPort = 1024 - defaultPrometheusHost = "0.0.0.0" - prometheusPortEnvName = "METRICS_PROMETHEUS_PORT" - prometheusHostEnvName = "METRICS_PROMETHEUS_HOST" + defaultBackendEnvName = "DEFAULT_METRICS_BACKEND" + defaultPrometheusPort = 9090 + defaultPrometheusReportingPeriod = 5 + defaultOpenCensusReportingPeriod = 60 + maxPrometheusPort = 65535 + minPrometheusPort = 1024 + defaultPrometheusHost = "0.0.0.0" + prometheusPortEnvName = "METRICS_PROMETHEUS_PORT" + prometheusHostEnvName = "METRICS_PROMETHEUS_HOST" ) var ( @@ -206,9 +208,9 @@ func createMetricsConfig(_ context.Context, ops ExporterOptions) (*metricsConfig } else { switch mc.backendDestination { case openCensus: - mc.reportingPeriod = time.Minute + mc.reportingPeriod = defaultOpenCensusReportingPeriod * time.Second case prometheus: - mc.reportingPeriod = 5 * time.Second + mc.reportingPeriod = defaultPrometheusReportingPeriod * time.Second } } return &mc, nil diff --git a/vendor/knative.dev/pkg/metrics/config_observability.go b/vendor/knative.dev/pkg/metrics/config_observability.go index b6affd2936..e766b071b6 100644 --- a/vendor/knative.dev/pkg/metrics/config_observability.go +++ b/vendor/knative.dev/pkg/metrics/config_observability.go @@ -71,6 +71,10 @@ type ObservabilityConfig struct { // OpenCensus. "None" disables all backends. RequestMetricsBackend string + // RequestMetricsReportingPeriodSeconds specifies the request metrics reporting period in sec at queue proxy, eg 1. + // If a zero or negative value is passed the default reporting period is used (10 secs). + RequestMetricsReportingPeriodSeconds int + // EnableProfiling indicates whether it is allowed to retrieve runtime profiling data from // the pods via an HTTP server in the format expected by the pprof visualization tool. EnableProfiling bool @@ -114,6 +118,12 @@ func NewObservabilityConfigFromConfigMap(configMap *corev1.ConfigMap) (*Observab return oc, nil } + defaultRequestMetricsReportingPeriod, err := getDefaultRequestMetricsReportingPeriod(configMap.Data) + if err != nil { + return nil, err + } + oc.RequestMetricsReportingPeriodSeconds = defaultRequestMetricsReportingPeriod + if err := cm.Parse(configMap.Data, cm.AsBool("logging.enable-var-log-collection", &oc.EnableVarLogCollection), cm.AsString("logging.revision-url-template", &oc.LoggingURLTemplate), @@ -121,6 +131,7 @@ func NewObservabilityConfigFromConfigMap(configMap *corev1.ConfigMap) (*Observab cm.AsBool(EnableReqLogKey, &oc.EnableRequestLog), cm.AsBool(EnableProbeReqLogKey, &oc.EnableProbeRequestLog), cm.AsString("metrics.request-metrics-backend-destination", &oc.RequestMetricsBackend), + cm.AsInt("metrics.request-metrics-reporting-period-seconds", &oc.RequestMetricsReportingPeriodSeconds), cm.AsBool("profiling.enable", &oc.EnableProfiling), cm.AsString("metrics.opencensus-address", &oc.MetricsCollectorAddress), ); err != nil { @@ -163,3 +174,27 @@ func ConfigMapName() string { } return "config-observability" } + +// Use the same as `metrics.reporting-period-seconds` for the default +// of `metrics.request-metrics-reporting-period-seconds` +func getDefaultRequestMetricsReportingPeriod(data map[string]string) (int, error) { + // Default backend is prometheus + period := defaultPrometheusReportingPeriod + if repStr := data[reportingPeriodKey]; repStr != "" { + repInt, err := strconv.Atoi(repStr) + if err != nil { + return -1, fmt.Errorf("invalid %s value %q", reportingPeriodKey, repStr) + } + period = repInt + } else { + if raw, ok := data["metrics.request-metrics-backend-destination"]; ok { + switch metricsBackend(raw) { + case prometheus: + period = defaultPrometheusReportingPeriod + case openCensus: + period = defaultOpenCensusReportingPeriod + } + } + } + return period, nil +} diff --git a/vendor/knative.dev/pkg/metrics/opencensus_exporter.go b/vendor/knative.dev/pkg/metrics/opencensus_exporter.go index eaeac4a566..59e33ab099 100644 --- a/vendor/knative.dev/pkg/metrics/opencensus_exporter.go +++ b/vendor/knative.dev/pkg/metrics/opencensus_exporter.go @@ -99,7 +99,7 @@ func getCredentials(component string, secret *corev1.Secret, logger *zap.Sugared return nil } return credentials.NewTLS(&tls.Config{ - MinVersion: tls.VersionTLS12, + MinVersion: tls.VersionTLS13, GetClientCertificate: func(*tls.CertificateRequestInfo) (*tls.Certificate, error) { cert, err := tls.X509KeyPair(secret.Data["client-cert.pem"], secret.Data["client-key.pem"]) if err != nil { diff --git a/vendor/knative.dev/pkg/webhook/env.go b/vendor/knative.dev/pkg/webhook/env.go index 01d52c8b09..ffb7570110 100644 --- a/vendor/knative.dev/pkg/webhook/env.go +++ b/vendor/knative.dev/pkg/webhook/env.go @@ -17,6 +17,7 @@ limitations under the License. package webhook import ( + "crypto/tls" "fmt" "os" "strconv" @@ -28,7 +29,9 @@ const ( // Webhook is the name of the override key used inside of the logging config for Webhook Controller. webhookNameEnvKey = "WEBHOOK_NAME" - secretNameEnvKey = "WEBHOOK_SECRET_NAME" + secretNameEnvKey = "WEBHOOK_SECRET_NAME" //nolint:gosec // This is not a hardcoded credential + + tlsMinVersionEnvKey = "WEBHOOK_TLS_MIN_VERSION" ) // PortFromEnv returns the webhook port set by portEnvKey, or default port if env var is not set. @@ -50,11 +53,11 @@ func NameFromEnv() string { return webhook } - panic(fmt.Sprintf(`The environment variable %q is not set. + panic(fmt.Sprintf(`The environment variable %[1]q is not set. This should be unique for the webhooks in a namespace If this is a process running on Kubernetes, then initialize this variable via: env: - - name: WEBHOOK_NAME + - name: %[1]s value: webhook `, webhookNameEnvKey)) } @@ -66,3 +69,16 @@ func SecretNameFromEnv(defaultSecretName string) string { } return secret } + +func TLSMinVersionFromEnv(defaultTLSMinVersion uint16) uint16 { + switch tlsMinVersion := os.Getenv(tlsMinVersionEnvKey); tlsMinVersion { + case "1.2": + return tls.VersionTLS12 + case "1.3": + return tls.VersionTLS13 + case "": + return defaultTLSMinVersion + default: + panic(fmt.Sprintf("the environment variable %q has to be either '1.2' or '1.3'", tlsMinVersionEnvKey)) + } +} diff --git a/vendor/knative.dev/pkg/webhook/webhook.go b/vendor/knative.dev/pkg/webhook/webhook.go index 6099e6ac51..779d388d22 100644 --- a/vendor/knative.dev/pkg/webhook/webhook.go +++ b/vendor/knative.dev/pkg/webhook/webhook.go @@ -40,6 +40,10 @@ import ( // Options contains the configuration for the webhook type Options struct { + // TLSMinVersion contains the minimum TLS version that is acceptable to communicate with the API server. + // TLS 1.3 is the minimum version if not specified otherwise. + TLSMinVersion uint16 + // ServiceName is the service name of the webhook. ServiceName string @@ -119,6 +123,13 @@ func New( opts.StatsReporter = reporter } + defaultTLSMinVersion := uint16(tls.VersionTLS13) + if opts.TLSMinVersion == 0 { + opts.TLSMinVersion = TLSMinVersionFromEnv(defaultTLSMinVersion) + } else if opts.TLSMinVersion != tls.VersionTLS12 && opts.TLSMinVersion != tls.VersionTLS13 { + return nil, fmt.Errorf("unsupported TLS version: %d", opts.TLSMinVersion) + } + syncCtx, cancel := context.WithCancel(context.Background()) webhook = &Webhook{ @@ -136,7 +147,7 @@ func New( secretInformer := kubeinformerfactory.Get(ctx).Core().V1().Secrets() webhook.tlsConfig = &tls.Config{ - MinVersion: tls.VersionTLS12, + MinVersion: opts.TLSMinVersion, // If we return (nil, error) the client sees - 'tls: internal error" // If we return (nil, nil) the client sees - 'tls: no certificates configured' diff --git a/vendor/knative.dev/reconciler-test/pkg/resources/job/job.yaml b/vendor/knative.dev/reconciler-test/pkg/resources/job/job.yaml index 2269966a95..ec894aad83 100644 --- a/vendor/knative.dev/reconciler-test/pkg/resources/job/job.yaml +++ b/vendor/knative.dev/reconciler-test/pkg/resources/job/job.yaml @@ -12,7 +12,7 @@ metadata: {{ if .labels }} labels: {{ range $key, $value := .labels }} - {{ $key }}: {{ $value }} + {{ $key }}: "{{ $value }}" {{ end }} {{ end }} spec: @@ -34,7 +34,7 @@ spec: {{ if .podlabels }} labels: {{ range $key, $value := .podlabels }} - {{ $key }}: {{ $value }} + {{ $key }}: "{{ $value }}" {{ end }} {{ end }} {{ end }} diff --git a/vendor/knative.dev/reconciler-test/pkg/resources/secret/secret.yaml b/vendor/knative.dev/reconciler-test/pkg/resources/secret/secret.yaml index bb828eeea9..d5a3f194ad 100644 --- a/vendor/knative.dev/reconciler-test/pkg/resources/secret/secret.yaml +++ b/vendor/knative.dev/reconciler-test/pkg/resources/secret/secret.yaml @@ -12,7 +12,7 @@ metadata: {{ if .labels }} labels: {{ range $key, $value := .labels }} - {{ $key }}: {{ $value }} + {{ $key }}: "{{ $value }}" {{ end }} {{ end }} {{ if .type }} diff --git a/vendor/knative.dev/reconciler-test/pkg/resources/service/service.yaml b/vendor/knative.dev/reconciler-test/pkg/resources/service/service.yaml index 90646a409c..d8c312ad0c 100644 --- a/vendor/knative.dev/reconciler-test/pkg/resources/service/service.yaml +++ b/vendor/knative.dev/reconciler-test/pkg/resources/service/service.yaml @@ -26,14 +26,14 @@ metadata: {{ if .labels }} labels: {{ range $key, $value := .labels }} - {{ $key }}: {{ $value }} + {{ $key }}: "{{ $value }}" {{ end }} {{ end }} spec: {{ if .selectors }} selector: {{ range $key, $value := .selectors }} - {{ $key }}: {{ $value }} + {{ $key }}: "{{ $value }}" {{ end }} {{ end }} ports: diff --git a/vendor/modules.txt b/vendor/modules.txt index 7d9b6f1bc4..a8b822a2a2 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -1221,7 +1221,7 @@ k8s.io/utils/net k8s.io/utils/pointer k8s.io/utils/strings/slices k8s.io/utils/trace -# knative.dev/eventing v0.36.1-0.20230309084530-05f6d84ad43c +# knative.dev/eventing v0.36.7 ## explicit; go 1.18 knative.dev/eventing/cmd/event_display knative.dev/eventing/pkg/apis/config @@ -1343,6 +1343,7 @@ knative.dev/eventing/test/rekt/resources/channel knative.dev/eventing/test/rekt/resources/channel_impl knative.dev/eventing/test/rekt/resources/containersource knative.dev/eventing/test/rekt/resources/delivery +knative.dev/eventing/test/rekt/resources/flaker knative.dev/eventing/test/rekt/resources/pingsource knative.dev/eventing/test/rekt/resources/source knative.dev/eventing/test/rekt/resources/subscription @@ -1368,11 +1369,11 @@ knative.dev/eventing/test/upgrade/prober/wathola/fetcher knative.dev/eventing/test/upgrade/prober/wathola/forwarder knative.dev/eventing/test/upgrade/prober/wathola/receiver knative.dev/eventing/test/upgrade/prober/wathola/sender -# knative.dev/hack v0.0.0-20230228173453-3de51aff69a3 +# knative.dev/hack v0.0.0-20230412013450-4b3f2300c1ad ## explicit; go 1.18 knative.dev/hack knative.dev/hack/shell -# knative.dev/pkg v0.0.0-20230309013522-c5dd1d1264ba +# knative.dev/pkg v0.0.0-20230414154551-53f04b373cc9 ## explicit; go 1.18 knative.dev/pkg/apiextensions/storageversion knative.dev/pkg/apiextensions/storageversion/cmd/migrate @@ -1482,7 +1483,7 @@ knative.dev/pkg/webhook/json knative.dev/pkg/webhook/resourcesemantics knative.dev/pkg/webhook/resourcesemantics/defaulting knative.dev/pkg/webhook/resourcesemantics/validation -# knative.dev/reconciler-test v0.0.0-20230307080119-d52257e4e606 +# knative.dev/reconciler-test v0.0.0-20230413132853-06956b6259d6 ## explicit; go 1.18 knative.dev/reconciler-test/cmd/eventshub knative.dev/reconciler-test/pkg/environment