From 760bd46b3270a6d464395be19d3788c6c2b2b602 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A1s=20Kerekes?= Date: Tue, 10 Nov 2020 15:37:31 -0800 Subject: [PATCH 1/5] Fix a race condition between creating a watch and initiating the action that emits the event it is watching for --- pkg/eventing/v1beta1/client.go | 11 +++++++--- pkg/serving/v1/client.go | 29 ++++++++++++++++++------ pkg/wait/wait_for_ready.go | 39 ++++++++++----------------------- pkg/wait/wait_for_ready_test.go | 18 +++++---------- 4 files changed, 48 insertions(+), 49 deletions(-) diff --git a/pkg/eventing/v1beta1/client.go b/pkg/eventing/v1beta1/client.go index 92e056ffab..c2c631dc0a 100644 --- a/pkg/eventing/v1beta1/client.go +++ b/pkg/eventing/v1beta1/client.go @@ -245,12 +245,17 @@ func (c *knEventingClient) DeleteBroker(name string, timeout time.Duration) erro return c.deleteBroker(name, apis_v1.DeletePropagationBackground) } waitC := make(chan error) + watcher, err := c.WatchBroker(name, timeout) + if err != nil { + return nil + } + defer watcher.Stop() go func() { - waitForEvent := wait.NewWaitForEvent("broker", c.WatchBroker, func(evt *watch.Event) bool { return evt.Type == watch.Deleted }) - err, _ := waitForEvent.Wait(name, wait.Options{Timeout: &timeout}, wait.NoopMessageCallback()) + waitForEvent := wait.NewWaitForEvent("broker", func(evt *watch.Event) bool { return evt.Type == watch.Deleted }) + err, _ := waitForEvent.Wait(watcher, name, wait.Options{Timeout: &timeout}, wait.NoopMessageCallback()) waitC <- err }() - err := c.deleteBroker(name, apis_v1.DeletePropagationForeground) + err = c.deleteBroker(name, apis_v1.DeletePropagationForeground) if err != nil { return err } diff --git a/pkg/serving/v1/client.go b/pkg/serving/v1/client.go index 108a1890ec..c5aa30d27e 100644 --- a/pkg/serving/v1/client.go +++ b/pkg/serving/v1/client.go @@ -319,12 +319,17 @@ func (cl *knServingClient) DeleteService(serviceName string, timeout time.Durati return cl.deleteService(serviceName, v1.DeletePropagationBackground) } waitC := make(chan error) + watcher, err := cl.WatchService(serviceName, timeout) + if err != nil { + return nil + } + defer watcher.Stop() go func() { - waitForEvent := wait.NewWaitForEvent("service", cl.WatchService, func(evt *watch.Event) bool { return evt.Type == watch.Deleted }) - err, _ := waitForEvent.Wait(serviceName, wait.Options{Timeout: &timeout}, wait.NoopMessageCallback()) + waitForEvent := wait.NewWaitForEvent("service", func(evt *watch.Event) bool { return evt.Type == watch.Deleted }) + err, _ := waitForEvent.Wait(watcher, serviceName, wait.Options{Timeout: &timeout}, wait.NoopMessageCallback()) waitC <- err }() - err := cl.deleteService(serviceName, v1.DeletePropagationForeground) + err = cl.deleteService(serviceName, v1.DeletePropagationForeground) if err != nil { return err } @@ -346,8 +351,13 @@ func (cl *knServingClient) deleteService(serviceName string, propagationPolicy v // Wait for a service to become ready, but not longer than provided timeout func (cl *knServingClient) WaitForService(name string, timeout time.Duration, msgCallback wait.MessageCallback) (error, time.Duration) { - waitForReady := wait.NewWaitForReady("service", cl.WatchService, serviceConditionExtractor) - return waitForReady.Wait(name, wait.Options{Timeout: &timeout}, msgCallback) + watcher, err := cl.WatchService(name, timeout) + if err != nil { + return err, timeout + } + defer watcher.Stop() + waitForReady := wait.NewWaitForReady("service", serviceConditionExtractor) + return waitForReady.Wait(watcher, name, wait.Options{Timeout: &timeout}, msgCallback) } // Get the configuration for a service @@ -460,9 +470,14 @@ func (cl *knServingClient) DeleteRevision(name string, timeout time.Duration) er return cl.deleteRevision(name) } waitC := make(chan error) + watcher, err := cl.WatchRevision(name, timeout) + if err != nil { + return err + } + defer watcher.Stop() go func() { - waitForEvent := wait.NewWaitForEvent("revision", cl.WatchRevision, func(evt *watch.Event) bool { return evt.Type == watch.Deleted }) - err, _ := waitForEvent.Wait(name, wait.Options{Timeout: &timeout}, wait.NoopMessageCallback()) + waitForEvent := wait.NewWaitForEvent("revision", func(evt *watch.Event) bool { return evt.Type == watch.Deleted }) + err, _ := waitForEvent.Wait(watcher, name, wait.Options{Timeout: &timeout}, wait.NoopMessageCallback()) waitC <- err }() err = cl.deleteRevision(name) diff --git a/pkg/wait/wait_for_ready.go b/pkg/wait/wait_for_ready.go index eac8fdb993..855176b526 100644 --- a/pkg/wait/wait_for_ready.go +++ b/pkg/wait/wait_for_ready.go @@ -27,16 +27,14 @@ import ( // Callbacks and configuration used while waiting type waitForReadyConfig struct { - watchMaker WatchMaker conditionsExtractor ConditionsExtractor kind string } // Callbacks and configuration used while waiting for event type waitForEvent struct { - watchMaker WatchMaker - eventDone EventDone - kind string + eventDone EventDone + kind string } // EventDone is a marker to stop actual waiting on given event state @@ -49,7 +47,7 @@ type Wait interface { // Wait on resource the resource with this name // and write event messages for unknown event to the status writer. // Returns an error (if any) and the overall time it took to wait - Wait(name string, options Options, msgCallback MessageCallback) (error, time.Duration) + Wait(watcher watch.Interface, name string, options Options, msgCallback MessageCallback) (error, time.Duration) } type Options struct { @@ -71,21 +69,19 @@ type ConditionsExtractor func(obj runtime.Object) (apis.Conditions, error) type MessageCallback func(durationSinceState time.Duration, message string) // NewWaitForReady waits until the condition is set to Ready == True -func NewWaitForReady(kind string, watchMaker WatchMaker, extractor ConditionsExtractor) Wait { +func NewWaitForReady(kind string, extractor ConditionsExtractor) Wait { return &waitForReadyConfig{ kind: kind, - watchMaker: watchMaker, conditionsExtractor: extractor, } } // NewWaitForEvent creates a Wait object which waits until a specific event (i.e. when // the EventDone function returns true) -func NewWaitForEvent(kind string, watchMaker WatchMaker, eventDone EventDone) Wait { +func NewWaitForEvent(kind string, eventDone EventDone) Wait { return &waitForEvent{ - kind: kind, - watchMaker: watchMaker, - eventDone: eventDone, + kind: kind, + eventDone: eventDone, } } @@ -112,13 +108,13 @@ func NoopMessageCallback() MessageCallback { // (e.g. "service"), `timeout` is a timeout after which the watch should be cancelled if no // target state has been entered yet and `out` is used for printing out status messages // msgCallback gets called for every event with an 'Ready' condition == UNKNOWN with the event's message. -func (w *waitForReadyConfig) Wait(name string, options Options, msgCallback MessageCallback) (error, time.Duration) { +func (w *waitForReadyConfig) Wait(watcher watch.Interface, name string, options Options, msgCallback MessageCallback) (error, time.Duration) { timeout := options.timeoutWithDefault() floatingTimeout := timeout for { start := time.Now() - retry, timeoutReached, err := w.waitForReadyCondition(start, name, floatingTimeout, options.errorWindowWithDefault(), msgCallback) + retry, timeoutReached, err := w.waitForReadyCondition(watcher, start, name, floatingTimeout, options.errorWindowWithDefault(), msgCallback) if err != nil { return err, time.Since(start) } @@ -141,13 +137,7 @@ func (w *waitForReadyConfig) Wait(name string, options Options, msgCallback Mess // An errorWindow can be specified which takes into account of intermediate "false" ready conditions. So before returning // an error, this methods waits for the errorWindow duration and if an "True" or "Unknown" event arrives in the meantime // for the "Ready" condition, then the method continues to wait. -func (w *waitForReadyConfig) waitForReadyCondition(start time.Time, name string, timeout time.Duration, errorWindow time.Duration, msgCallback MessageCallback) (retry bool, timeoutReached bool, err error) { - - watcher, err := w.watchMaker(name, timeout) - if err != nil { - return false, false, err - } - defer watcher.Stop() +func (w *waitForReadyConfig) waitForReadyCondition(watcher watch.Interface, start time.Time, name string, timeout time.Duration, errorWindow time.Duration, msgCallback MessageCallback) (retry bool, timeoutReached bool, err error) { // channel used to transport the error that has been received errChan := make(chan error) @@ -239,13 +229,8 @@ func (w *waitForReadyConfig) waitForReadyCondition(start time.Time, name string, } // Wait until the expected EventDone is satisfied -func (w *waitForEvent) Wait(name string, options Options, msgCallback MessageCallback) (error, time.Duration) { +func (w *waitForEvent) Wait(watcher watch.Interface, name string, options Options, msgCallback MessageCallback) (error, time.Duration) { timeout := options.timeoutWithDefault() - watcher, err := w.watchMaker(name, timeout) - if err != nil { - return err, 0 - } - defer watcher.Stop() start := time.Now() // channel used to transport the error errChan := make(chan error) @@ -255,7 +240,7 @@ func (w *waitForEvent) Wait(name string, options Options, msgCallback MessageCal select { case <-timer.C: return fmt.Errorf("timeout: %s '%s' not ready after %d seconds", w.kind, name, int(timeout/time.Second)), time.Since(start) - case err = <-errChan: + case err := <-errChan: return err, time.Since(start) case event := <-watcher.ResultChan(): if w.eventDone(&event) { diff --git a/pkg/wait/wait_for_ready_test.go b/pkg/wait/wait_for_ready_test.go index 09992a7110..487886d058 100644 --- a/pkg/wait/wait_for_ready_test.go +++ b/pkg/wait/wait_for_ready_test.go @@ -41,15 +41,12 @@ func TestAddWaitForReady(t *testing.T) { waitForReady := NewWaitForReady( "blub", - func(name string, timeout time.Duration) (watch.Interface, error) { - return fakeWatchApi, nil - }, func(obj runtime.Object) (apis.Conditions, error) { return apis.Conditions(obj.(*servingv1.Service).Status.Conditions), nil }) fakeWatchApi.Start() var msgs []string - err, _ := waitForReady.Wait("foobar", Options{Timeout: &tc.timeout}, func(_ time.Duration, msg string) { + err, _ := waitForReady.Wait(fakeWatchApi, "foobar", Options{Timeout: &tc.timeout}, func(_ time.Duration, msg string) { msgs = append(msgs, msg) }) close(fakeWatchApi.eventChan) @@ -69,8 +66,8 @@ func TestAddWaitForReady(t *testing.T) { // check messages assert.Assert(t, cmp.DeepEqual(tc.messagesExpected, msgs), "%d: Messages expected to be equal", i) - if fakeWatchApi.StopCalled != 1 { - t.Errorf("%d: Exactly one 'stop' should be called, but got %d", i, fakeWatchApi.StopCalled) + if fakeWatchApi.StopCalled != 0 { + t.Errorf("%d: Exactly zero 'stop' should be called, but got %d", i, fakeWatchApi.StopCalled) } } @@ -82,13 +79,10 @@ func TestAddWaitForDelete(t *testing.T) { waitForEvent := NewWaitForEvent( "blub", - func(name string, timeout time.Duration) (watch.Interface, error) { - return fakeWatchAPI, nil - }, func(evt *watch.Event) bool { return evt.Type == watch.Deleted }) fakeWatchAPI.Start() - err, _ := waitForEvent.Wait("foobar", Options{Timeout: &tc.timeout}, NoopMessageCallback()) + err, _ := waitForEvent.Wait(fakeWatchAPI, "foobar", Options{Timeout: &tc.timeout}, NoopMessageCallback()) close(fakeWatchAPI.eventChan) if tc.errorText == "" && err != nil { @@ -103,8 +97,8 @@ func TestAddWaitForDelete(t *testing.T) { } } - if fakeWatchAPI.StopCalled != 1 { - t.Errorf("%d: Exactly one 'stop' should be called, but got %d", i, fakeWatchAPI.StopCalled) + if fakeWatchAPI.StopCalled != 0 { + t.Errorf("%d: Exactly zero 'stop' should be called, but got %d", i, fakeWatchAPI.StopCalled) } } } From 3e05e6d8aa8b1d482500c373d1d08d117f4f666d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A1s=20Kerekes?= Date: Wed, 11 Nov 2020 09:03:09 -0800 Subject: [PATCH 2/5] update changelog --- CHANGELOG.adoc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index c561ba9a40..5854d06899 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -37,6 +37,9 @@ | Fix various misspellings and linter items | https://github.com/knative/client/pull/1057[#1057] +| 🐛 +| Fix a race condition when using Kubernetes watches +| https://github.com/knative/client/pull/ | 🎁 | Add Aliases to Help Command and Remove Aliases in Short From 190a1c3e41ea2636d841c2a2a914fabd1bbcc896 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A1s=20Kerekes?= Date: Wed, 11 Nov 2020 09:04:49 -0800 Subject: [PATCH 3/5] add PR ID to changelog entry --- CHANGELOG.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index 5854d06899..7e6f9fef12 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -39,7 +39,7 @@ | 🐛 | Fix a race condition when using Kubernetes watches -| https://github.com/knative/client/pull/ +| https://github.com/knative/client/pull/1113[#1113] | 🎁 | Add Aliases to Help Command and Remove Aliases in Short From 440e8e4a1df7491a7b8326ee253e1a1c9f2cf71e Mon Sep 17 00:00:00 2001 From: Andras Kerekes Date: Wed, 11 Nov 2020 09:14:04 -0800 Subject: [PATCH 4/5] Fix merge in Changelog --- CHANGELOG.adoc | 4 ---- 1 file changed, 4 deletions(-) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index f545ca2ed8..1f73a59f6f 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -21,10 +21,6 @@ | Fix a race condition when using Kubernetes watches | https://github.com/knative/client/pull/1113[#1113] -<<<<<<< HEAD - -======= ->>>>>>> 0c1cc24531dc572c3f7d83d23fb5037deadda2fd ### v0.19.0 (2020-11-11) [cols="1,10,3", options="header", width="100%"] |=== From 0ee64360a8eee878fe50f9c5c34af342626c9f9e Mon Sep 17 00:00:00 2001 From: Andras Kerekes Date: Wed, 11 Nov 2020 09:21:01 -0800 Subject: [PATCH 5/5] Fix table format in Changelog --- CHANGELOG.adoc | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index 1f73a59f6f..da7ae00b6c 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -20,6 +20,7 @@ | 🐛 | Fix a race condition when using Kubernetes watches | https://github.com/knative/client/pull/1113[#1113] +|=== ### v0.19.0 (2020-11-11) [cols="1,10,3", options="header", width="100%"]