Auto PR: Regenerating the Go SDK (ec0083f539696d6b9a2b4f07210b8847aa4b73e2)

resource-manager/containerinstance/2023-05-01/client.go

@@ -4,20 +4,25 @@ package v2023_05_01
 // Licensed under the MIT License. See NOTICE.txt in the project root for license information.
 
 import (
-	"github.com/Azure/go-autorest/autorest"
+	"fmt"
+
 	"github.com/hashicorp/go-azure-sdk/resource-manager/containerinstance/2023-05-01/containerinstance"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
+	sdkEnv "github.com/hashicorp/go-azure-sdk/sdk/environments"
 )
 
 type Client struct {
 	ContainerInstance *containerinstance.ContainerInstanceClient
 }
 
-func NewClientWithBaseURI(endpoint string, configureAuthFunc func(c *autorest.Client)) Client {
-
-	containerInstanceClient := containerinstance.NewContainerInstanceClientWithBaseURI(endpoint)
-	configureAuthFunc(&containerInstanceClient.Client)
-
-	return Client{
-		ContainerInstance: &containerInstanceClient,
+func NewClientWithBaseURI(sdkApi sdkEnv.Api, configureFunc func(c *resourcemanager.Client)) (*Client, error) {
+	containerInstanceClient, err := containerinstance.NewContainerInstanceClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building ContainerInstance client: %+v", err)
 	}
+	configureFunc(containerInstanceClient.Client)
+
+	return &Client{
+		ContainerInstance: containerInstanceClient,
+	}, nil
 }

resource-manager/containerinstance/2023-05-01/containerinstance/client.go

@@ -1,18 +1,26 @@
 package containerinstance
 
-import "github.com/Azure/go-autorest/autorest"
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
+	sdkEnv "github.com/hashicorp/go-azure-sdk/sdk/environments"
+)
 
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License. See NOTICE.txt in the project root for license information.
 
 type ContainerInstanceClient struct {
-	Client  autorest.Client
-	baseUri string
+	Client *resourcemanager.Client
 }
 
-func NewContainerInstanceClientWithBaseURI(endpoint string) ContainerInstanceClient {
-	return ContainerInstanceClient{
-		Client:  autorest.NewClientWithUserAgent(userAgent()),
-		baseUri: endpoint,
+func NewContainerInstanceClientWithBaseURI(sdkApi sdkEnv.Api) (*ContainerInstanceClient, error) {
+	client, err := resourcemanager.NewResourceManagerClient(sdkApi, "containerinstance", defaultApiVersion)
+	if err != nil {
+		return nil, fmt.Errorf("instantiating ContainerInstanceClient: %+v", err)
 	}
+
+	return &ContainerInstanceClient{
+		Client: client,
+	}, nil
 }

resource-manager/containerinstance/2023-05-01/containerinstance/constants.go

@@ -1,6 +1,10 @@
 package containerinstance
 
-import "strings"
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
 
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License. See NOTICE.txt in the project root for license information.
@@ -19,6 +23,19 @@ func PossibleValuesForContainerGroupIPAddressType() []string {
 	}
 }
 
+func (s *ContainerGroupIPAddressType) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseContainerGroupIPAddressType(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseContainerGroupIPAddressType(input string) (*ContainerGroupIPAddressType, error) {
 	vals := map[string]ContainerGroupIPAddressType{
 		"private": ContainerGroupIPAddressTypePrivate,
@@ -47,6 +64,19 @@ func PossibleValuesForContainerGroupNetworkProtocol() []string {
 	}
 }
 
+func (s *ContainerGroupNetworkProtocol) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseContainerGroupNetworkProtocol(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseContainerGroupNetworkProtocol(input string) (*ContainerGroupNetworkProtocol, error) {
 	vals := map[string]ContainerGroupNetworkProtocol{
 		"tcp": ContainerGroupNetworkProtocolTCP,
@@ -75,6 +105,19 @@ func PossibleValuesForContainerGroupPriority() []string {
 	}
 }
 
+func (s *ContainerGroupPriority) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseContainerGroupPriority(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseContainerGroupPriority(input string) (*ContainerGroupPriority, error) {
 	vals := map[string]ContainerGroupPriority{
 		"regular": ContainerGroupPriorityRegular,
@@ -105,6 +148,19 @@ func PossibleValuesForContainerGroupRestartPolicy() []string {
 	}
 }
 
+func (s *ContainerGroupRestartPolicy) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseContainerGroupRestartPolicy(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseContainerGroupRestartPolicy(input string) (*ContainerGroupRestartPolicy, error) {
 	vals := map[string]ContainerGroupRestartPolicy{
 		"always":    ContainerGroupRestartPolicyAlways,
@@ -136,6 +192,19 @@ func PossibleValuesForContainerGroupSku() []string {
 	}
 }
 
+func (s *ContainerGroupSku) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseContainerGroupSku(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseContainerGroupSku(input string) (*ContainerGroupSku, error) {
 	vals := map[string]ContainerGroupSku{
 		"confidential": ContainerGroupSkuConfidential,
@@ -165,6 +234,19 @@ func PossibleValuesForContainerNetworkProtocol() []string {
 	}
 }
 
+func (s *ContainerNetworkProtocol) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseContainerNetworkProtocol(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseContainerNetworkProtocol(input string) (*ContainerNetworkProtocol, error) {
 	vals := map[string]ContainerNetworkProtocol{
 		"tcp": ContainerNetworkProtocolTCP,
@@ -199,6 +281,19 @@ func PossibleValuesForDnsNameLabelReusePolicy() []string {
 	}
 }
 
+func (s *DnsNameLabelReusePolicy) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseDnsNameLabelReusePolicy(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseDnsNameLabelReusePolicy(input string) (*DnsNameLabelReusePolicy, error) {
 	vals := map[string]DnsNameLabelReusePolicy{
 		"noreuse":            DnsNameLabelReusePolicyNoreuse,
@@ -232,6 +327,19 @@ func PossibleValuesForGpuSku() []string {
 	}
 }
 
+func (s *GpuSku) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseGpuSku(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseGpuSku(input string) (*GpuSku, error) {
 	vals := map[string]GpuSku{
 		"k80":  GpuSkuKEightZero,
@@ -261,6 +369,19 @@ func PossibleValuesForLogAnalyticsLogType() []string {
 	}
 }
 
+func (s *LogAnalyticsLogType) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseLogAnalyticsLogType(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseLogAnalyticsLogType(input string) (*LogAnalyticsLogType, error) {
 	vals := map[string]LogAnalyticsLogType{
 		"containerinsights":     LogAnalyticsLogTypeContainerInsights,
@@ -289,6 +410,19 @@ func PossibleValuesForOperatingSystemTypes() []string {
 	}
 }
 
+func (s *OperatingSystemTypes) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseOperatingSystemTypes(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseOperatingSystemTypes(input string) (*OperatingSystemTypes, error) {
 	vals := map[string]OperatingSystemTypes{
 		"linux":   OperatingSystemTypesLinux,
@@ -317,6 +451,19 @@ func PossibleValuesForScheme() []string {
 	}
 }
 
+func (s *Scheme) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseScheme(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
 func parseScheme(input string) (*Scheme, error) {
 	vals := map[string]Scheme{
 		"http":  SchemeHTTP,

resource-manager/containerinstance/2023-05-01/containerinstance/method_containergroupscreateorupdate.go

@@ -0,0 +1,75 @@
+package containerinstance
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/hashicorp/go-azure-sdk/sdk/client"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/pollers"
+	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
+	"github.com/hashicorp/go-azure-sdk/sdk/odata"
+)
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+type ContainerGroupsCreateOrUpdateOperationResponse struct {
+	Poller       pollers.Poller
+	HttpResponse *http.Response
+	OData        *odata.OData
+	Model        *ContainerGroup
+}
+
+// ContainerGroupsCreateOrUpdate ...
+func (c ContainerInstanceClient) ContainerGroupsCreateOrUpdate(ctx context.Context, id ContainerGroupId, input ContainerGroup) (result ContainerGroupsCreateOrUpdateOperationResponse, err error) {
+	opts := client.RequestOptions{
+		ContentType: "application/json; charset=utf-8",
+		ExpectedStatusCodes: []int{
+			http.StatusCreated,
+			http.StatusOK,
+		},
+		HttpMethod: http.MethodPut,
+		Path:       id.ID(),
+	}
+
+	req, err := c.Client.NewRequest(ctx, opts)
+	if err != nil {
+		return
+	}
+
+	if err = req.Marshal(input); err != nil {
+		return
+	}
+
+	var resp *client.Response
+	resp, err = req.Execute(ctx)
+	if resp != nil {
+		result.OData = resp.OData
+		result.HttpResponse = resp.Response
+	}
+	if err != nil {
+		return
+	}
+
+	result.Poller, err = resourcemanager.PollerFromResponse(resp, c.Client)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// ContainerGroupsCreateOrUpdateThenPoll performs ContainerGroupsCreateOrUpdate then polls until it's completed
+func (c ContainerInstanceClient) ContainerGroupsCreateOrUpdateThenPoll(ctx context.Context, id ContainerGroupId, input ContainerGroup) error {
+	result, err := c.ContainerGroupsCreateOrUpdate(ctx, id, input)
+	if err != nil {
+		return fmt.Errorf("performing ContainerGroupsCreateOrUpdate: %+v", err)
+	}
+
+	if err := result.Poller.PollUntilDone(ctx); err != nil {
+		return fmt.Errorf("polling after ContainerGroupsCreateOrUpdate: %+v", err)
+	}
+
+	return nil
+}