doc: update quickstart and migration guide (Azure#17612)

* doc: update quickstart and migration guide

* fix: wrong usage of log.Fatal

* fix: tab problem

* fix: add version prerequisites

* fix: tab problem, context change and some minor change

Author: tadelesh

documentation/MIGRATION_GUIDE.md

@@ -18,7 +18,8 @@ This document is intended for users that are familiar with the previous version
 
 ## Prerequisites
 
-The last 2 released stable versions of Go are supported.
+- Go 1.18
+- Latest version of resource management modules
 
 ## General Changes
 
@@ -46,7 +47,7 @@ client.Authorizer = authorizer
 
 ```go
 credential, err := azidentity.NewClientSecretCredential("<TenantId>", "<ClientId>", "<ClientSecret>", nil)
-client := armresources.NewResourceGroupsClient("<SubscriptionId>", credential, nil)
+client, err := armresources.NewResourceGroupsClient("<SubscriptionId>", credential, nil)
 ```
 
 For detailed information on the benefits of using the new authentication types, please refer to [this page](https://github.com/Azure/azure-sdk-for-go/blob/main/sdk/azidentity/README.md)
@@ -55,42 +56,32 @@ For detailed information on the benefits of using the new authentication types,
 
 There are some minor changes in the error handling.
 
-- When there is an error in the SDK request, in the previous version (`services/**/mgmt/**`), the return value will all be non-nil, and you can get the raw HTTP response from the response value. In the latest version (`sdk/resourcemanager/**/arm**`), the first return value will be empty and you need to convert the error to the `azcore.HTTPResponse` interface to get the raw HTTP response. When the request is successful and there is no error returned, you can get the raw HTTP response in `RawResponse` property of the first return value.
+- When there is an error in the SDK request, in the previous version (`services/**/mgmt/**`), the return value will all be non-nil, and you can get the raw HTTP response from the response value. In the latest version (`sdk/resourcemanager/**/arm**`), the first return value will be empty and you need to convert the error to the `azcore.ResponseError` interface to get the raw HTTP response. When the request is successful and there is no error returned, you can get the raw HTTP response from request context.
 
 **Previous version (`services/**/mgmt/**`)**
 
 ```go
-resp, err := resourceGroupsClient.CreateOrUpdate(context.Background(), resourceGroupName, resourceGroupParameters)
+resp, err := resourceGroupsClient.CreateOrUpdate(context.TODO(), resourceGroupName, resourceGroupParameters)
 if err != nil {
-	log.Fatalf("Status code: %d", resp.Response.Response.StatusCode)
+    log.Fatalf("Status code: %d", resp.Response().StatusCode)
 }
 ```
 
 **Latest version (`sdk/resourcemanager/**/arm**`)**
 
 ```go
-resp, err := resourceGroupsClient.CreateOrUpdate(context.Background(), resourceGroupName, resourceGroupParameters, nil)
+var rawResponse *http.Response
+ctxWithResp := runtime.WithCaptureResponse(context.TODO(), &rawResponse)
+resp, err := resourceGroupsClient.CreateOrUpdate(ctxWithResp, resourceGroupName, resourceGroupParameters, nil)
 if err != nil {
-    var respErr azcore.HTTPResponse
+    var respErr *azcore.ResponseError
     if errors.As(err, &respErr) {
-        log.Fatalf("Status code: %d", respErr.RawResponse().StatusCode)
+        log.Fatalf("Status code: %d", respErr.RawResponse.StatusCode)
+    } else {
+        log.Fatalf("Other error: %+v", err)
     }
-	log.Fatalf("Other error: %+v", err)
 }
-```
-
-**When there is no error in latest version (`sdk/resourcemanager/**/arm**`)**
-
-```go
-resp, err := resourceGroupsClient.CreateOrUpdate(context.Background(), resourceGroupName, resourceGroupParameters, nil)
-if err != nil {
-    var respErr azcore.HTTPResponse
-    if errors.As(err, &respErr) {
-        log.Fatalf("Status code: %d", respErr.RawResponse().StatusCode)
-    }
-    log.Fatalf("Other error: %+v", err)
-}
-log.Printf("Status code: %d", resp.RawResponse.StatusCode)
+log.Printf("Status code: %d", rawResponse.StatusCode)
 ```
 
 ### Long Running Operations
@@ -102,28 +93,28 @@ In the latest version, if a request is a long-running operation, the function na
 **Previous version (`services/**/mgmt/**`)**
 
 ```go
-future, err := virtualMachinesClient.CreateOrUpdate(context.Background(), "<resource group name>", "<virtual machine name>", param)
+future, err := virtualMachinesClient.CreateOrUpdate(context.TODO(), "<resource group name>", "<virtual machine name>", param)
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
-if err := future.WaitForCompletionRef(context.Background(), virtualMachinesClient.Client); err != nil {
-	log.Fatal(err)
+if err := future.WaitForCompletionRef(context.TODO(), virtualMachinesClient.Client); err != nil {
+    log.Fatal(err)
 }
 vm, err := future.Result(virtualMachinesClient)
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
 log.Printf("virtual machine ID: %v", *vm.ID)
 ```
 
 **Latest version (`sdk/resourcemanager/**/arm**`)**
 
 ```go
-poller, err := client.BeginCreateOrUpdate(context.Background(), "<resource group name>", "<virtual machine name>", param, nil)
+poller, err := client.BeginCreateOrUpdate(context.TODO(), "<resource group name>", "<virtual machine name>", param, nil)
 if err != nil {
-	log.Fatal(err)
+    log.Fatal(err)
 }
-resp, err := poller.PollUntilDone(context.Background(), 30*time.Second)
+resp, err := poller.PollUntilDone(context.TODO(), 30*time.Second)
 if err != nil {
     log.Fatal(err)
 }
@@ -139,15 +130,15 @@ In the latest version, if a request is a paginated operation, a struct `**Pager`
 **Previous version (`services/**/mgmt/**`)**
 
 ```go
-pager, err := resourceGroupsClient.List(context.Background(), "", nil)
+pager, err := resourceGroupsClient.List(context.TODO(), "", nil)
 if err != nil {
     log.Fatal(err)
 }
 for p.NotDone() {
     for _, v := range pager.Values() {
         log.Printf("resource group ID: %s\n", *rg.ID)
     }
-    if err := pager.NextWithContext(context.Background()); err != nil   {
+    if err := pager.NextWithContext(context.TODO()); err != nil   {
         log.Fatal(err)
     }
 }
@@ -156,15 +147,16 @@ for p.NotDone() {
 **Latest version (`sdk/resourcemanager/**/arm**`)**
 
 ```go
-pager := resourceGroupsClient.List(nil)
-for pager.NextPage(context.Background()) {
-    for _, rg := range pager.PageResponse().ResourceGroupListResult.Value {
+pager := resourceGroupsClient.NewListPager(nil)
+for pager.More() {
+    nextResult, err := pager.NextPage(ctx)
+    if err != nil {
+        log.Fatalf("failed to advance page: %v", err)
+    }
+    for _, rg := range nextResult.Value {
         log.Printf("resource group ID: %s\n", *rg.ID)
     }
 }
-if err := pager.Err(); err != nil {
-    log.Fatalf("failed to advance page: %v", err)
-}
 ```
 
 ### Customized Policy
@@ -195,7 +187,7 @@ options := &arm.ClientOptions{
         Transport: &httpClient,
     },
 }
-client := armresources.NewResourceGroupsClient("<SubscriptionId>", credential, options)
+client, err := armresources.NewResourceGroupsClient("<SubscriptionId>", credential, options)
 ```
 
 ## Need help?

documentation/new-version-quickstart.md

@@ -23,6 +23,8 @@ If you are an existing user of the older version of Azure management library for
 Prerequisites
 -------------
 
+You will need Go 1.18 and latest version of resource management modules.
+
 You will need the following values to authenticate to Azure
 
 -   **Subscription ID**
@@ -112,12 +114,12 @@ Once you have a credential, you will need to decide what service to use and crea
 To show an example, we will create a client to manage Virtual Machines. The code to achieve this task would be:
 
 ```go
-client := armcompute.NewVirtualMachinesClient("<subscription ID>", credential, nil)
+client, err := armcompute.NewVirtualMachinesClient("<subscription ID>", credential, nil)
 ```
 You can use the same pattern to connect with other Azure services that you are using. For example, in order to manage Virtual Network resources, you would install the Network package and create a `VirtualNetwork` Client:
 
 ```go
-client := armnetwork.NewVirtualNetworksClient("<subscription ID>", credential, nil)
+client, err := armnetwork.NewVirtualNetworksClient("<subscription ID>", credential, nil)
 ```
 
 Interacting with Azure Resources
@@ -151,8 +153,6 @@ import (
     "time"
 
     "github.com/Azure/azure-sdk-for-go/sdk/azcore"
-    "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
-    "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
     "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
     "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
     "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources"
@@ -162,7 +162,7 @@ import (
 ***Define some global variables***
 ```go
 var (
-    ctx                 = context.Background()
+    ctx                 = context.TODO()
     subscriptionId      = os.Getenv("AZURE_SUBSCRIPTION_ID")
     location            = "westus2"
     resourceGroupName   = "resourceGroupName"
@@ -172,14 +172,19 @@ var (
 
 ***Write a function to create a resource group***
 ```go
-func createResourceGroup(ctx context.Context, credential azcore.TokenCredential) (armresources.ResourceGroupsCreateOrUpdateResponse, error) {
-	rgClient := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
+func createResourceGroup(ctx context.Context, credential azcore.TokenCredential) (*armresources.ResourceGroupsClientCreateOrUpdateResponse, error) {
+    rgClient, err := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
+    if err != nil {
+        return nil, err
+    }
 
     param := armresources.ResourceGroup{
-        Location: to.StringPtr(location),
+        Location: to.Ptr(location),
     }
 
-    return rgClient.CreateOrUpdate(context.Background(), resourceGroupName, param, nil)
+    resp, err := rgClient.CreateOrUpdate(ctx, resourceGroupName, param, nil)
+
+    return &resp, err
 }
 ```
 
@@ -207,43 +212,59 @@ Example: Managing Resource Groups
 ***Update a resource group***
 
 ```go
-func updateResourceGroup(ctx context.Context, credential azcore.TokenCredential) (armresources.ResourceGroupsUpdateResponse, error) {
-    rgClient := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
+func updateResourceGroup(ctx context.Context, credential azcore.TokenCredential) (*armresources.ResourceGroupsClientUpdateResponse, error) {
+    rgClient, err := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
+    if err != nil {
+        return nil, err
+    }
 
     update := armresources.ResourceGroupPatchable{
         Tags: map[string]*string{
-            "new": to.StringPtr("tag"),
+            "new": to.Ptr("tag"),
         },
     }
-    return rgClient.Update(ctx, resourceGroupName, update, nil)
+
+    resp,err :=rgClient.Update(ctx, resourceGroupName, update, nil)
+    
+    return  &resp, err
 }
 ```
 
 ***List all resource groups***
 
 ```go
 func listResourceGroups(ctx context.Context, credential azcore.TokenCredential) ([]*armresources.ResourceGroup, error) {
-    rgClient := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
-    
-    pager := rgClient.List(nil)
-    
+    rgClient, err := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
+    if err != nil {
+        return nil, err
+    }
+
+    pager := rgClient.NewListPager(nil)
+
     var resourceGroups []*armresources.ResourceGroup
-    for pager.NextPage(ctx) {
-        resp := pager.PageResponse()
-        if resp.ResourceGroupListResult.Value != nil {
-            resourceGroups = append(resourceGroups, resp.ResourceGroupListResult.Value...)
+    for pager.More() {
+        nextResult, err := pager.NextPage(ctx)
+        if err != nil {
+            return nil, err
+        }
+        if nextResult.ResourceGroupListResult.Value != nil {
+            resourceGroups = append(resourceGroups, nextResult.ResourceGroupListResult.Value...)
         }
     }
-    return resourceGroups, pager.Err()
+
+    return resourceGroups, nil
 }
 ```
 
 ***Delete a resource group***
 
 ```go
 func deleteResourceGroup(ctx context.Context, credential azcore.TokenCredential) error {
-    rgClient := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
-    
+    rgClient, err := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)
+    if err != nil {
+        return err
+    }
+
     poller, err := rgClient.BeginDelete(ctx, resourceGroupName, nil)
     if err != nil {
         return err
@@ -256,10 +277,10 @@ func deleteResourceGroup(ctx context.Context, credential azcore.TokenCredential)
 ***Invoking the update, list and delete of resource group in the main function***
 ```go
 func main() {
-	cred, err := azidentity.NewDefaultAzureCredential(nil)
-	if err != nil {
-		log.Fatalf("authentication failure: %+v", err)
-	}
+    cred, err := azidentity.NewDefaultAzureCredential(nil)
+    if err != nil {
+        log.Fatalf("authentication failure: %+v", err)
+    }
 
     resourceGroup, err := createResourceGroup(ctx, cred)
     if err != nil {
@@ -283,7 +304,7 @@ func main() {
         log.Fatalf("cannot delete resource group: %+v", err)
     }
     log.Printf("Resource Group deleted")
-})
+}
 ```
 
 Example: Managing Virtual Machines
@@ -297,11 +318,12 @@ Long Running Operations
 In the samples above, you might notice that some operations have a ``Begin`` prefix (for example, ``BeginDelete``). This indicates the operation is a Long-Running Operation (LRO). For resource management libraries, this kind of operation is quite common since certain resource operations may take a while to finish. When you need to use those LROs, you will need to use a poller and keep polling for the result until it is done. To illustrate this pattern, here is an example
 
 ```go
-poller, err := client.BeginCreate(context.Background(), "resource_identifier", "additonal_parameter")
+ctx := context.TODO()
+poller, err := client.BeginCreate(ctx, "resource_identifier", "additonal_parameter")
 if err != nil {
     // handle error...
 }
-resp, err = poller.PollUntilDone(context.Background(), 5 * time.Second)
+resp, err = poller.PollUntilDone(ctx, 5 * time.Second)
 if err != nil {
     // handle error...
 }