From 1bdd7af705cf8bdb6728d5329fe483ca7a338169 Mon Sep 17 00:00:00 2001 From: Navid Shaikh Date: Wed, 25 Nov 2020 15:02:36 +0530 Subject: [PATCH 1/3] Cross-compile the kn binary for linux/s390x (#1083) --- hack/build.sh | 2 ++ hack/release.sh | 12 +++++++----- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/hack/build.sh b/hack/build.sh index 8aa1be8fda..ae5d3f075c 100755 --- a/hack/build.sh +++ b/hack/build.sh @@ -284,6 +284,8 @@ cross_build() { GOOS=darwin GOARCH=amd64 go build -mod=vendor -ldflags "${ld_flags}" -o ./kn-darwin-amd64 ./cmd/... || failed=1 echo " 🎠 kn-windows-amd64.exe" GOOS=windows GOARCH=amd64 go build -mod=vendor -ldflags "${ld_flags}" -o ./kn-windows-amd64.exe ./cmd/... || failed=1 + echo " Z kn-linux-s390x" + GOOS=linux GOARCH=s390x go build -mod=vendor -ldflags "${ld_flags}" -o ./kn-linux-s390x ./cmd/... || failed=1 return ${failed} } diff --git a/hack/release.sh b/hack/release.sh index 0fac736ebc..263fb1a524 100755 --- a/hack/release.sh +++ b/hack/release.sh @@ -35,13 +35,15 @@ function build_release() { GOOS=darwin GOARCH=amd64 go build -mod=vendor -ldflags "${ld_flags}" -o ./kn-darwin-amd64 ./cmd/... echo "🚧 🎠 Building for Windows" GOOS=windows GOARCH=amd64 go build -mod=vendor -ldflags "${ld_flags}" -o ./kn-windows-amd64.exe ./cmd/... + echo "🚧 Z Building for Linux(s390x)" + GOOS=linux GOARCH=s390x go build -mod=vendor -ldflags "${ld_flags}" -o ./kn-linux-s390x ./cmd/... echo "🚧 🐳 Building the container image" ko resolve --strict ${KO_FLAGS} -f config/ > kn-image-location.yaml - ARTIFACTS_TO_PUBLISH="kn-darwin-amd64 kn-linux-amd64 kn-windows-amd64.exe kn-image-location.yaml" - if type sha256sum >/dev/null 2>&1; then - echo "🧮 Checksum:" - sha256sum ${ARTIFACTS_TO_PUBLISH} - fi + ARTIFACTS_TO_PUBLISH="kn-darwin-amd64 kn-linux-amd64 kn-linux-arm64 kn-windows-amd64.exe kn-linux-s390x kn-image-location.yaml" + sha256sum "${ARTIFACTS_TO_PUBLISH}" > checksums.txt + ARTIFACTS_TO_PUBLISH="${ARTIFACTS_TO_PUBLISH} checksums.txt" + echo "🧮 Checksum:" + cat checksums.txt } main $@ From 75d5fbe663d6063253614d174bfa5dae4f822b8a Mon Sep 17 00:00:00 2001 From: Navid Shaikh Date: Wed, 25 Nov 2020 12:48:51 +0530 Subject: [PATCH 2/3] Update CHANGELOG for kn v0.18.4 --- CHANGELOG.adoc | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index 381b58fe82..2163484995 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -12,6 +12,17 @@ | https://github.com/knative/client/pull/[#] //// +## v0.18.4 (2020-11-25) + +[cols="1,10,3", options="header", width="100%"] +|=== +| | Description | PR + +| 🎁 +| Add kn _s390x_ binary to the release +| https://github.com/knative/client/pull/1083[#1083] +|=== + ## v0.18.3 (2020-11-24) [cols="1,10,3", options="header", width="100%"] From f158303054845f6917d5d2acc68516c968c2e354 Mon Sep 17 00:00:00 2001 From: Navid Shaikh Date: Wed, 25 Nov 2020 18:57:58 +0530 Subject: [PATCH 3/3] Fix race conditions when creating watches (#1113) * Fix a race condition between creating a watch and initiating the action that emits the event it is watching for * update changelog * add PR ID to changelog entry * Fix merge in Changelog * Fix table format in Changelog --- CHANGELOG.adoc | 4 ++++ 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 +++++---------- 5 files changed, 52 insertions(+), 49 deletions(-) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index 2163484995..5e6919bc3a 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -18,6 +18,10 @@ |=== | | Description | PR +| 🐛 +| Fix a race condition when using Kubernetes watches +| https://github.com/knative/client/pull/1113[#1113] + | 🎁 | Add kn _s390x_ binary to the release | https://github.com/knative/client/pull/1083[#1083] diff --git a/pkg/eventing/v1beta1/client.go b/pkg/eventing/v1beta1/client.go index c080d18f5b..863ebcaa43 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 b464eebfec..0fb129fc0b 100644 --- a/pkg/serving/v1/client.go +++ b/pkg/serving/v1/client.go @@ -275,12 +275,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 } @@ -302,8 +307,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 @@ -398,9 +408,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) } } }