feat: flexible cancellation when waiting for deploy state

Author: vbrown608

go/porcelain/context/context.go

@@ -3,8 +3,8 @@ package context
 import (
 	"context"
 
-	"github.com/sirupsen/logrus"
 	"github.com/go-openapi/runtime"
+	"github.com/sirupsen/logrus"
 )
 
 type Context interface {

go/porcelain/deploy.go

@@ -4,6 +4,7 @@ import (
 	"archive/zip"
 	"bufio"
 	"bytes"
+	gocontext "context"
 	"crypto/sha1"
 	"crypto/sha256"
 	"debug/elf"
@@ -273,7 +274,13 @@ func (n *Netlify) DoDeploy(ctx context.Context, options *DeployOptions, deploy *
 
 	if n.overCommitted(options.files) {
 		var err error
-		deploy, err = n.WaitUntilDeployReady(ctx, deploy, options.PreProcessTimeout)
+
+		timeout := options.PreProcessTimeout
+		if timeout <= 0 {
+			timeout = preProcessingTimeout
+		}
+		deployReadyCtx, _ := gocontext.WithTimeout(ctx, timeout)
+		deploy, err = n.WaitUntilDeployReady(deployReadyCtx, deploy)
 		if err != nil {
 			if options.Observer != nil {
 				options.Observer.OnFailedDelta(deployFiles)
@@ -305,58 +312,48 @@ func (n *Netlify) DoDeploy(ctx context.Context, options *DeployOptions, deploy *
 	return deploy, nil
 }
 
-func (n *Netlify) waitForState(ctx context.Context, d *models.Deploy, timeout time.Duration, states ...string) (*models.Deploy, error) {
+func (n *Netlify) waitForState(ctx context.Context, d *models.Deploy, states ...string) (*models.Deploy, error) {
 	authInfo := context.GetAuthInfo(ctx)
 	ticker := time.NewTicker(2 * time.Second)
 	defer ticker.Stop()
 
 	params := operations.NewGetSiteDeployParams().WithSiteID(d.SiteID).WithDeployID(d.ID)
-	start := time.Now()
-	for t := range ticker.C {
-		resp, err := n.Operations.GetSiteDeploy(params, authInfo)
-		if err != nil {
-			time.Sleep(3 * time.Second)
-			continue
-		}
-		context.GetLogger(ctx).WithFields(logrus.Fields{
-			"deploy_id": d.ID,
-			"state":     resp.Payload.State,
-		}).Debugf("Waiting until deploy state in %s", states)
-
-		for _, state := range states {
-			if resp.Payload.State == state {
-				return resp.Payload, nil
+	for {
+		select {
+		case <-ctx.Done():
+			return nil, fmt.Errorf("timed out while waiting to enter states [%s]", strings.Join(states, ", "))
+		case <-ticker.C:
+			resp, err := n.Operations.GetSiteDeploy(params, authInfo)
+			if err != nil {
+				time.Sleep(3 * time.Second)
+				continue
+			}
+			context.GetLogger(ctx).WithFields(logrus.Fields{
+				"deploy_id": d.ID,
+				"state":     resp.Payload.State,
+			}).Debugf("Waiting until deploy state in %s", states)
+
+			for _, state := range states {
+				if resp.Payload.State == state {
+					return resp.Payload, nil
+				}
 			}
-		}
-
-		if resp.Payload.State == "error" {
-			return nil, fmt.Errorf("Error: entered error state while waiting to enter states: %s", strings.Join(states, ", "))
-		}
 
-		if t.Sub(start) > timeout {
-			return nil, fmt.Errorf("Error: deploy timed out while waiting to enter states: %s", strings.Join(states, ", "))
+			if resp.Payload.State == "error" {
+				return nil, fmt.Errorf("entered error state while waiting to enter states [%s]", strings.Join(states, ", "))
+			}
 		}
 	}
-
-	return d, nil
 }
 
 // WaitUntilDeployReady blocks until the deploy is in the "prepared" or "ready" state.
-func (n *Netlify) WaitUntilDeployReady(ctx context.Context, d *models.Deploy, timeout time.Duration) (*models.Deploy, error) {
-	if timeout <= 0 {
-		timeout = preProcessingTimeout
-	}
-
-	return n.waitForState(ctx, d, timeout, "prepared", "ready")
+func (n *Netlify) WaitUntilDeployReady(ctx context.Context, d *models.Deploy) (*models.Deploy, error) {
+	return n.waitForState(ctx, d, "prepared", "ready")
 }
 
 // WaitUntilDeployLive blocks until the deploy is in the or "ready" state. At this point, the deploy is ready to recieve traffic.
-func (n *Netlify) WaitUntilDeployLive(ctx context.Context, d *models.Deploy, timeout time.Duration) (*models.Deploy, error) {
-	if timeout <= 0 {
-		timeout = preProcessingTimeout
-	}
-
-	return n.waitForState(ctx, d, timeout, "ready")
+func (n *Netlify) WaitUntilDeployLive(ctx context.Context, d *models.Deploy) (*models.Deploy, error) {
+	return n.waitForState(ctx, d, "ready")
 }
 
 func (n *Netlify) uploadFiles(ctx context.Context, d *models.Deploy, files *deployFiles, observer DeployObserver, t uploadType, timeout time.Duration) error {

go/porcelain/deploy_test.go

@@ -2,6 +2,7 @@ package porcelain
 
 import (
 	"bytes"
+	gocontext "context"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
@@ -10,12 +11,14 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/go-openapi/runtime"
 	apiClient "github.com/go-openapi/runtime/client"
 	"github.com/go-openapi/strfmt"
 	"github.com/netlify/open-api/go/models"
 	"github.com/netlify/open-api/go/plumbing/operations"
+	"github.com/netlify/open-api/go/porcelain/context"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -135,6 +138,31 @@ func TestConcurrentFileUpload(t *testing.T) {
 	}
 }
 
+func TestWaitUntilDeployLive_Timeout(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
+		rw.Header().Set("Content-Type", "application/json; charset=utf-8")
+		rw.Write([]byte(`{ "state": "chillin" }`))
+	}))
+	defer server.Close()
+
+	httpClient := http.DefaultClient
+	authInfo := runtime.ClientAuthInfoWriterFunc(func(r runtime.ClientRequest, _ strfmt.Registry) error {
+		r.SetHeaderParam("User-Agent", "buildbot")
+		r.SetHeaderParam("Authorization", "Bearer 1234")
+		return nil
+	})
+
+	hu, _ := url.Parse(server.URL)
+	tr := apiClient.NewWithClient(hu.Host, "/api/v1", []string{"http"}, httpClient)
+	client := NewRetryable(tr, strfmt.Default, 1)
+
+	ctx := context.WithAuthInfo(gocontext.Background(), authInfo)
+	ctx, _ = gocontext.WithTimeout(ctx, 50*time.Millisecond)
+	_, err := client.WaitUntilDeployLive(ctx, &models.Deploy{})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "timed out")
+}
+
 func TestWalk_IgnoreNodeModulesInRoot(t *testing.T) {
 	dir, err := ioutil.TempDir("", "deploy")
 	require.Nil(t, err)