Handle RELO LRO synchronous completion (Azure#18353)

If the initial response contains a provisioning state use it.  This will
prevent extra polling in the case the operation is in a terminal state.

Author: jhendrixMSFT

sdk/azcore/CHANGELOG.md

@@ -7,6 +7,7 @@
 ### Breaking Changes
 
 ### Bugs Fixed
+* Avoid polling when a RELO LRO synchronously terminates.
 
 ### Other Changes
 

sdk/azcore/internal/pollers/async/async.go

@@ -71,6 +71,13 @@ func New[T any](pl exported.Pipeline, resp *http.Response, finalState pollers.Fi
 	if !pollers.IsValidURL(asyncURL) {
 		return nil, fmt.Errorf("invalid polling URL %s", asyncURL)
 	}
+	// check for provisioning state.  if the operation is a RELO
+	// and terminates synchronously this will prevent extra polling.
+	// it's ok if there's no provisioning state.
+	state, _ := pollers.GetProvisioningState(resp)
+	if state == "" {
+		state = pollers.StatusInProgress
+	}
 	p := &Poller[T]{
 		pl:         pl,
 		resp:       resp,
@@ -79,7 +86,7 @@ func New[T any](pl exported.Pipeline, resp *http.Response, finalState pollers.Fi
 		OrigURL:    resp.Request.URL.String(),
 		Method:     resp.Request.Method,
 		FinalState: finalState,
-		CurState:   pollers.StatusInProgress,
+		CurState:   state,
 	}
 	return p, nil
 }

sdk/azcore/internal/pollers/async/async_test.go

@@ -244,3 +244,15 @@ func TestPollFailedError(t *testing.T) {
 	require.Error(t, err)
 	require.Nil(t, resp)
 }
+
+func TestSynchronousCompletion(t *testing.T) {
+	resp := initialResponse(http.MethodPut, io.NopCloser(strings.NewReader(`{ "properties": { "provisioningState": "Succeeded" } }`)))
+	resp.Header.Set(shared.HeaderAzureAsync, fakePollingURL)
+	resp.Header.Set(shared.HeaderLocation, fakeResourceURL)
+	poller, err := New[struct{}](exported.Pipeline{}, resp, "")
+	require.NoError(t, err)
+	require.Equal(t, fakePollingURL, poller.AsyncURL)
+	require.Equal(t, fakeResourceURL, poller.LocURL)
+	require.Equal(t, pollers.StatusSucceeded, poller.CurState)
+	require.True(t, poller.Done())
+}

sdk/azcore/internal/pollers/loc/loc.go

@@ -64,12 +64,19 @@ func New[T any](pl exported.Pipeline, resp *http.Response) (*Poller[T], error) {
 	if !pollers.IsValidURL(locURL) {
 		return nil, fmt.Errorf("invalid polling URL %s", locURL)
 	}
+	// check for provisioning state.  if the operation is a RELO
+	// and terminates synchronously this will prevent extra polling.
+	// it's ok if there's no provisioning state.
+	state, _ := pollers.GetProvisioningState(resp)
+	if state == "" {
+		state = pollers.StatusInProgress
+	}
 	return &Poller[T]{
 		pl:       pl,
 		resp:     resp,
 		Type:     kind,
 		PollURL:  locURL,
-		CurState: pollers.StatusInProgress,
+		CurState: state,
 	}, nil
 }
 

sdk/azcore/internal/pollers/loc/loc_test.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported"
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers"
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared"
 	"github.com/stretchr/testify/require"
 )
@@ -29,6 +30,7 @@ func initialResponse() *http.Response {
 	return &http.Response{
 		Header:     http.Header{},
 		StatusCode: http.StatusAccepted,
+		Body:       http.NoBody,
 	}
 }
 
@@ -161,3 +163,14 @@ func TestUpdateFailedWithProvisioningState(t *testing.T) {
 	var respErr *azcore.ResponseError
 	require.ErrorAs(t, err, &respErr)
 }
+
+func TestSynchronousCompletion(t *testing.T) {
+	resp := initialResponse()
+	resp.Body = io.NopCloser(strings.NewReader(`{ "properties": { "provisioningState": "Succeeded" } }`))
+	resp.Header.Set(shared.HeaderLocation, fakeLocationURL)
+	poller, err := New[struct{}](exported.Pipeline{}, resp)
+	require.NoError(t, err)
+	require.Equal(t, fakeLocationURL, poller.PollURL)
+	require.Equal(t, pollers.StatusSucceeded, poller.CurState)
+	require.True(t, poller.Done())
+}