diff --git a/data/data/azure/variables-azure.tf b/data/data/azure/variables-azure.tf
index bb026a054f1..9607c822672 100644
--- a/data/data/azure/variables-azure.tf
+++ b/data/data/azure/variables-azure.tf
@@ -134,3 +134,9 @@ This determined whether User defined routing will be used for egress to Internet
When false, Standard LB will be used for egress to the Internet.
EOF
}
+
+variable "azure_image_path" {
+ type = string
+ default = ""
+ description = "A path on the host system to an Azure VHD. Used only for uploading RHCOS images to Azure Stack."
+}
diff --git a/data/data/azurestack/vnet/main.tf b/data/data/azurestack/vnet/main.tf
new file mode 100644
index 00000000000..aeff3005384
--- /dev/null
+++ b/data/data/azurestack/vnet/main.tf
@@ -0,0 +1,108 @@
+locals {
+ tags = merge(
+ {
+ "kubernetes.io_cluster.${var.cluster_id}" = "owned"
+ },
+ var.azure_extra_tags,
+ )
+ description = "Created By OpenShift Installer"
+ upload = var.azure_image_path != ""
+ rhcos_blob_uri = local.upload ? azurestackprivate_vhd_blob.rhcos_image[0].url : azurestack_storage_blob.rhcos_image[0].url
+}
+
+provider "azurestack" {
+ arm_endpoint = var.azure_arm_endpoint
+ subscription_id = var.azure_subscription_id
+ client_id = var.azure_client_id
+ client_secret = var.azure_client_secret
+ tenant_id = var.azure_tenant_id
+}
+
+provider "azurestackprivate" {
+ arm_endpoint = var.azure_arm_endpoint
+ subscription_id = var.azure_subscription_id
+ client_id = var.azure_client_id
+ client_secret = var.azure_client_secret
+ tenant_id = var.azure_tenant_id
+}
+
+resource "random_string" "storage_suffix" {
+ length = 5
+ upper = false
+ special = false
+}
+
+resource "azurestack_resource_group" "main" {
+ count = var.azure_resource_group_name == "" ? 1 : 0
+
+ name = "${var.cluster_id}-rg"
+ location = var.azure_region
+ tags = local.tags
+}
+
+data "azurestack_resource_group" "main" {
+ name = var.azure_resource_group_name == "" ? "${var.cluster_id}-rg" : var.azure_resource_group_name
+
+ depends_on = [azurestack_resource_group.main]
+}
+
+data "azurestack_resource_group" "network" {
+ count = var.azure_preexisting_network ? 1 : 0
+
+ name = var.azure_network_resource_group_name
+}
+
+resource "azurestack_storage_account" "cluster" {
+ name = "cluster${random_string.storage_suffix.result}"
+ resource_group_name = data.azurestack_resource_group.main.name
+ location = var.azure_region
+ account_tier = "Standard"
+ account_replication_type = "LRS"
+}
+
+# copy over the vhd to cluster resource group and create an image using that
+resource "azurestack_storage_container" "vhd" {
+ name = "vhd"
+ resource_group_name = data.azurestack_resource_group.main.name
+ storage_account_name = azurestack_storage_account.cluster.name
+}
+
+resource "azurestack_storage_blob" "rhcos_image" {
+ count = local.upload ? 0 : 1
+
+ name = "rhcos${random_string.storage_suffix.result}.vhd"
+ resource_group_name = data.azurestack_resource_group.main.name
+ storage_account_name = azurestack_storage_account.cluster.name
+ storage_container_name = azurestack_storage_container.vhd.name
+ type = "page"
+ source_uri = var.azure_image_url
+}
+
+resource "azurestackprivate_vhd_blob" "rhcos_image" {
+ count = local.upload ? 1 : 0
+
+ name = "rhcos${random_string.storage_suffix.result}.vhd"
+ resource_group_name = data.azurestack_resource_group.main.name
+ storage_account_name = azurestack_storage_account.cluster.name
+ storage_container_name = azurestack_storage_container.vhd.name
+ source = var.azure_image_path
+}
+
+resource "azurestack_image" "cluster" {
+ name = var.cluster_id
+ resource_group_name = data.azurestack_resource_group.main.name
+ location = var.azure_region
+
+ os_disk {
+ os_type = "Linux"
+ os_state = "Generalized"
+ blob_uri = local.rhcos_blob_uri
+ }
+}
+
+resource "azurestack_availability_set" "master_availability_set" {
+ name = "${var.cluster_id}-master"
+ resource_group_name = data.azurestack_resource_group.main.name
+ location = var.azure_region
+ managed = true
+}
diff --git a/go.mod b/go.mod
index 04eef72d97c..67328c9815c 100644
--- a/go.mod
+++ b/go.mod
@@ -18,6 +18,7 @@ require (
github.com/IBM/networking-go-sdk v0.14.0
github.com/IBM/platform-services-go-sdk v0.18.16
github.com/IBM/vpc-go-sdk v1.0.1
+ github.com/Microsoft/azure-vhd-utils v0.0.0-20181115010904-44cbada2ece3
github.com/Netflix/go-expect v0.0.0-20190729225929-0e00d9168667 // indirect
github.com/antchfx/xpath v1.1.2 // indirect
github.com/apparentlymart/go-cidr v1.1.0
@@ -60,6 +61,7 @@ require (
github.com/mitchellh/cli v1.1.1
github.com/openshift-metal3/terraform-provider-ironic v0.2.6
github.com/openshift/api v0.0.0-20210622200201-7740bfb97397
+ github.com/openshift/azure-sdk-for-go v4.0.0-beta.0.20160930180624-772f34e02704+incompatible
github.com/openshift/client-go v0.0.0-20210409155308-a8e62c60e930
github.com/openshift/cloud-credential-operator v0.0.0-20200316201045-d10080b52c9e
github.com/openshift/cluster-api-provider-gcp v0.0.1-0.20201203141909-4dc702fd57a5
diff --git a/go.sum b/go.sum
index e67dd220dd6..3622e6809ed 100644
--- a/go.sum
+++ b/go.sum
@@ -35,6 +35,7 @@ github.com/14rcole/gopopulate v0.0.0-20180821133914-b175b219e774/go.mod h1:6/0dY
github.com/360EntSecGroup-Skylar/excelize v1.4.1/go.mod h1:vnax29X2usfl7HHkBrX5EvSCJcmH3dT9luvxzu8iGAE=
github.com/AlecAivazis/survey/v2 v2.2.12 h1:5a07y93zA6SZ09gOa9wLVLznF5zTJMQ+pJ3cZK4IuO8=
github.com/AlecAivazis/survey/v2 v2.2.12/go.mod h1:6d4saEvBsfSHXeN1a5OA5m2+HJ2LuVokllnC77pAIKI=
+github.com/Azure/azure-sdk-for-go v5.0.0-beta.0.20161118192335-3b1282355199+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v29.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v35.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v36.2.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
@@ -171,6 +172,8 @@ github.com/Masterminds/goutils v1.1.0/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy86
github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
github.com/Masterminds/sprig v2.20.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o=
+github.com/Microsoft/azure-vhd-utils v0.0.0-20181115010904-44cbada2ece3 h1:gImoAO1xAcC1oDlYmD/X7dggsodGf2DFJOVE5m0ssms=
+github.com/Microsoft/azure-vhd-utils v0.0.0-20181115010904-44cbada2ece3/go.mod h1:u0H9gMieFLxkUy8RS0X8VbFWyPs2815qQAaitRbj6x0=
github.com/Microsoft/go-winio v0.4.11/go.mod h1:VhR8bwka0BXejwEJY73c50VrPtXAaKcyvVC4A4RozmA=
github.com/Microsoft/go-winio v0.4.13/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA=
github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw=
@@ -1427,6 +1430,8 @@ github.com/openshift/api v0.0.0-20210412212256-79bd8cfbbd59/go.mod h1:dZ4kytOo3s
github.com/openshift/api v0.0.0-20210416115537-a60c0dc032fd/go.mod h1:dZ4kytOo3svxJHNYd0J55hwe/6IQG5gAUHUE0F3Jkio=
github.com/openshift/api v0.0.0-20210622200201-7740bfb97397 h1:wp5My+8d2K2HIZw2yZblsIZawma5UrNQGPVcTev/HSA=
github.com/openshift/api v0.0.0-20210622200201-7740bfb97397/go.mod h1:izBmoXbUu3z5kUa4FjZhvekTsyzIWiOoaIgJiZBBMQs=
+github.com/openshift/azure-sdk-for-go v4.0.0-beta.0.20160930180624-772f34e02704+incompatible h1:4AfrWnnXZYNWpK0bLUKi0gIKAY0PNhvL2pHdpPt2ctc=
+github.com/openshift/azure-sdk-for-go v4.0.0-beta.0.20160930180624-772f34e02704+incompatible/go.mod h1:BCauxNrp488JtVPoyUV50x+FYZp8HvYd7iCL9NfpWfc=
github.com/openshift/baremetal-operator v0.0.0-20210706141527-5240e42f012a h1:7rEVkEhSyg7wxFsH5BWzG9svhlG3GSY+hhSGNjU20P8=
github.com/openshift/baremetal-operator v0.0.0-20210706141527-5240e42f012a/go.mod h1:N80LeH5dJtqtrknj5vxwRaXyfF1UdxLm74B/QpH8QI0=
github.com/openshift/baremetal-operator/apis v0.0.0-20210706141527-5240e42f012a h1:oXPw/sck0Lr0yAarZZCOCFE/3+9+UziPIIhREzhE2SU=
@@ -2395,6 +2400,7 @@ gopkg.in/square/go-jose.v2 v2.3.0/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76
gopkg.in/square/go-jose.v2 v2.3.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/urfave/cli.v1 v1.19.1/go.mod h1:vuBzUtMdQeixQj8LVd+/98pzhxNGQoyuPBlsXHOQNO0=
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
gopkg.in/yaml.v2 v2.1.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/pkg/asset/rhcos/image.go b/pkg/asset/rhcos/image.go
index 2f339ac1bd5..a69acac23fb 100644
--- a/pkg/asset/rhcos/image.go
+++ b/pkg/asset/rhcos/image.go
@@ -126,6 +126,13 @@ func osImage(config *types.InstallConfig) (string, error) {
}
return "", fmt.Errorf("%s: No openstack build found", st.FormatPrefix(archName))
case azure.Name:
+ if config.Azure.CloudName == azure.StackCloud {
+ if a, ok := streamArch.Artifacts["azurestack"]; ok {
+ return rhcos.FindArtifactURL(a)
+ }
+ return "", fmt.Errorf("%s: No azurestack build found", st.FormatPrefix(archName))
+ }
+
ext := streamArch.RHELCoreOSExtensions
if ext == nil {
return "", fmt.Errorf("%s: No azure build found", st.FormatPrefix(archName))
diff --git a/pkg/terraform/exec/plugins/azurestackprivate.go b/pkg/terraform/exec/plugins/azurestackprivate.go
new file mode 100644
index 00000000000..54aff157961
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate.go
@@ -0,0 +1,15 @@
+package plugins
+
+import (
+ "github.com/hashicorp/terraform-plugin-sdk/plugin"
+ "github.com/openshift/installer/pkg/terraform/exec/plugins/azurestackprivate"
+)
+
+func init() {
+ azurestackPrivateProvider := func() {
+ plugin.Serve(&plugin.ServeOpts{
+ ProviderFunc: azurestackprivate.Provider,
+ })
+ }
+ KnownPlugins["terraform-provider-azurestackprivate"] = azurestackPrivateProvider
+}
diff --git a/pkg/terraform/exec/plugins/azurestackprivate/config.go b/pkg/terraform/exec/plugins/azurestackprivate/config.go
new file mode 100644
index 00000000000..c53699f5424
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate/config.go
@@ -0,0 +1,340 @@
+package azurestackprivate
+
+import (
+ "context"
+ "fmt"
+ "os"
+ "sync"
+ "time"
+
+ "github.com/Azure/azure-sdk-for-go/profiles/2017-03-09/resources/mgmt/resources"
+ "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/compute/mgmt/compute"
+ "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network"
+ "github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/storage/mgmt/storage"
+ "github.com/Azure/azure-sdk-for-go/services/dns/mgmt/2016-04-01/dns"
+ "github.com/Azure/azure-sdk-for-go/services/graphrbac/1.6/graphrbac"
+ mainStorage "github.com/Azure/azure-sdk-for-go/storage"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/hashicorp/go-azure-helpers/authentication"
+ "github.com/hashicorp/go-azure-helpers/sender"
+ "github.com/hashicorp/terraform-plugin-sdk/httpclient"
+ "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+// ArmClient contains the handles to all the specific Azure Resource Manager
+// resource classes' respective clients.
+type ArmClient struct {
+ clientID string
+ tenantID string
+ subscriptionID string
+ terraformVersion string
+ usingServicePrincipal bool
+ environment azure.Environment
+ skipProviderRegistration bool
+
+ StopContext context.Context
+
+ // Authentication
+ servicePrincipalsClient graphrbac.ServicePrincipalsClient
+
+ // DNS
+ dnsClient dns.RecordSetsClient
+ zonesClient dns.ZonesClient
+
+ // Networking
+ ifaceClient network.InterfacesClient
+ localNetConnClient network.LocalNetworkGatewaysClient
+ secRuleClient network.SecurityRulesClient
+ vnetGatewayClient network.VirtualNetworkGatewaysClient
+ vnetGatewayConnectionsClient network.VirtualNetworkGatewayConnectionsClient
+
+ // Resources
+ providersClient resources.ProvidersClient
+ resourcesClient resources.Client
+
+ resourceGroupsClient resources.GroupsClient
+ deploymentsClient resources.DeploymentsClient
+
+ // Compute
+ availSetClient compute.AvailabilitySetsClient
+ diskClient compute.DisksClient
+ vmExtensionClient compute.VirtualMachineExtensionsClient
+ vmClient compute.VirtualMachinesClient
+ vmImageClient compute.VirtualMachineImagesClient
+ vmScaleSetClient compute.VirtualMachineScaleSetsClient
+ storageServiceClient storage.AccountsClient
+
+ // Network
+ vnetClient network.VirtualNetworksClient
+ secGroupClient network.SecurityGroupsClient
+ publicIPClient network.PublicIPAddressesClient
+ subnetClient network.SubnetsClient
+ loadBalancerClient network.LoadBalancersClient
+ routesClient network.RoutesClient
+ routeTablesClient network.RouteTablesClient
+}
+
+func (c *ArmClient) configureClient(client *autorest.Client, auth autorest.Authorizer) {
+ setUserAgent(client, c.terraformVersion)
+ client.Authorizer = auth
+ client.Sender = sender.BuildSender("AzureStack")
+ client.SkipResourceProviderRegistration = c.skipProviderRegistration
+ client.PollingDuration = 60 * time.Minute
+}
+
+func setUserAgent(client *autorest.Client, tfVersion string) {
+ tfUserAgent := httpclient.TerraformUserAgent(tfVersion)
+
+ // if the user agent already has a value append the Terraform user agent string
+ if curUserAgent := client.UserAgent; curUserAgent != "" {
+ client.UserAgent = fmt.Sprintf("%s %s", curUserAgent, tfUserAgent)
+ } else {
+ client.UserAgent = tfUserAgent
+ }
+
+ // append the CloudShell version to the user agent if it exists
+ if azureAgent := os.Getenv("AZURE_HTTP_USER_AGENT"); azureAgent != "" {
+ client.UserAgent = fmt.Sprintf("%s %s", client.UserAgent, azureAgent)
+ }
+}
+
+// getArmClient is a helper method which returns a fully instantiated
+// *ArmClient based on the Config's current settings.
+func getArmClient(authCfg *authentication.Config, tfVersion string, skipProviderRegistration bool) (*ArmClient, error) {
+ env, err := authentication.LoadEnvironmentFromUrl(authCfg.CustomResourceManagerEndpoint)
+ if err != nil {
+ return nil, err
+ }
+
+ // client declarations:
+ client := ArmClient{
+ clientID: authCfg.ClientID,
+ tenantID: authCfg.TenantID,
+ subscriptionID: authCfg.SubscriptionID,
+ terraformVersion: tfVersion,
+ environment: *env,
+ usingServicePrincipal: authCfg.AuthenticatedAsAServicePrincipal,
+ skipProviderRegistration: skipProviderRegistration,
+ }
+
+ oauth, err := authCfg.BuildOAuthConfig(env.ActiveDirectoryEndpoint)
+ if err != nil {
+ return nil, err
+ }
+
+ sender := sender.BuildSender("AzureStack")
+
+ // Resource Manager endpoints
+ endpoint := env.ResourceManagerEndpoint
+
+ // Instead of the same endpoint use token audience to get the correct token.
+ auth, err := authCfg.GetAuthorizationToken(sender, oauth, env.TokenAudience)
+ if err != nil {
+ return nil, err
+ }
+
+ // Graph Endpoints
+ graphEndpoint := env.GraphEndpoint
+ graphAuth, err := authCfg.GetAuthorizationToken(sender, oauth, graphEndpoint)
+ if err != nil {
+ return nil, err
+ }
+
+ client.registerAuthentication(graphEndpoint, client.tenantID, graphAuth, sender)
+ client.registerComputeClients(endpoint, client.subscriptionID, auth)
+ client.registerDNSClients(endpoint, client.subscriptionID, auth)
+ client.registerNetworkingClients(endpoint, client.subscriptionID, auth)
+ client.registerResourcesClients(endpoint, client.subscriptionID, auth)
+ client.registerStorageClients(endpoint, client.subscriptionID, auth)
+
+ return &client, nil
+}
+
+func (c *ArmClient) registerAuthentication(graphEndpoint, tenantID string, graphAuth autorest.Authorizer, sender autorest.Sender) {
+ servicePrincipalsClient := graphrbac.NewServicePrincipalsClientWithBaseURI(graphEndpoint, tenantID)
+ setUserAgent(&servicePrincipalsClient.Client, c.terraformVersion)
+ servicePrincipalsClient.Authorizer = graphAuth
+ servicePrincipalsClient.Sender = sender
+ servicePrincipalsClient.SkipResourceProviderRegistration = c.skipProviderRegistration
+ c.servicePrincipalsClient = servicePrincipalsClient
+}
+
+func (c *ArmClient) registerComputeClients(endpoint, subscriptionID string, auth autorest.Authorizer) {
+ availabilitySetsClient := compute.NewAvailabilitySetsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&availabilitySetsClient.Client, auth)
+ c.availSetClient = availabilitySetsClient
+
+ diskClient := compute.NewDisksClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&diskClient.Client, auth)
+ c.diskClient = diskClient
+
+ extensionsClient := compute.NewVirtualMachineExtensionsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&extensionsClient.Client, auth)
+ c.vmExtensionClient = extensionsClient
+
+ scaleSetsClient := compute.NewVirtualMachineScaleSetsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&scaleSetsClient.Client, auth)
+ c.vmScaleSetClient = scaleSetsClient
+
+ virtualMachinesClient := compute.NewVirtualMachinesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&virtualMachinesClient.Client, auth)
+ c.vmClient = virtualMachinesClient
+
+ virtualMachineImagesClient := compute.NewVirtualMachineImagesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&virtualMachineImagesClient.Client, auth)
+ c.vmImageClient = virtualMachineImagesClient
+}
+
+func (c *ArmClient) registerDNSClients(endpoint, subscriptionID string, auth autorest.Authorizer) {
+ dn := dns.NewRecordSetsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&dn.Client, auth)
+ c.dnsClient = dn
+
+ zo := dns.NewZonesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&zo.Client, auth)
+ c.zonesClient = zo
+}
+
+func (c *ArmClient) registerNetworkingClients(endpoint, subscriptionID string, auth autorest.Authorizer) {
+ interfacesClient := network.NewInterfacesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&interfacesClient.Client, auth)
+ c.ifaceClient = interfacesClient
+
+ gatewaysClient := network.NewVirtualNetworkGatewaysClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&gatewaysClient.Client, auth)
+ c.vnetGatewayClient = gatewaysClient
+
+ gatewayConnectionsClient := network.NewVirtualNetworkGatewayConnectionsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&gatewayConnectionsClient.Client, auth)
+ c.vnetGatewayConnectionsClient = gatewayConnectionsClient
+
+ localNetworkGatewaysClient := network.NewLocalNetworkGatewaysClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&localNetworkGatewaysClient.Client, auth)
+ c.localNetConnClient = localNetworkGatewaysClient
+
+ loadBalancersClient := network.NewLoadBalancersClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&loadBalancersClient.Client, auth)
+ c.loadBalancerClient = loadBalancersClient
+
+ networksClient := network.NewVirtualNetworksClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&networksClient.Client, auth)
+ c.vnetClient = networksClient
+
+ publicIPAddressesClient := network.NewPublicIPAddressesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&publicIPAddressesClient.Client, auth)
+ c.publicIPClient = publicIPAddressesClient
+
+ securityGroupsClient := network.NewSecurityGroupsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&securityGroupsClient.Client, auth)
+ c.secGroupClient = securityGroupsClient
+
+ securityRulesClient := network.NewSecurityRulesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&securityRulesClient.Client, auth)
+ c.secRuleClient = securityRulesClient
+
+ subnetsClient := network.NewSubnetsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&subnetsClient.Client, auth)
+ c.subnetClient = subnetsClient
+
+ routeTablesClient := network.NewRouteTablesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&routeTablesClient.Client, auth)
+ c.routeTablesClient = routeTablesClient
+
+ routesClient := network.NewRoutesClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&routesClient.Client, auth)
+ c.routesClient = routesClient
+}
+
+func (c *ArmClient) registerResourcesClients(endpoint, subscriptionID string, auth autorest.Authorizer) {
+ resourcesClient := resources.NewClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&resourcesClient.Client, auth)
+ c.resourcesClient = resourcesClient
+
+ deploymentsClient := resources.NewDeploymentsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&deploymentsClient.Client, auth)
+ c.deploymentsClient = deploymentsClient
+
+ resourceGroupsClient := resources.NewGroupsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&resourceGroupsClient.Client, auth)
+ c.resourceGroupsClient = resourceGroupsClient
+
+ providersClient := resources.NewProvidersClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&providersClient.Client, auth)
+ c.providersClient = providersClient
+}
+
+func (c *ArmClient) registerStorageClients(endpoint, subscriptionID string, auth autorest.Authorizer) {
+ accountsClient := storage.NewAccountsClientWithBaseURI(endpoint, subscriptionID)
+ c.configureClient(&accountsClient.Client, auth)
+ c.storageServiceClient = accountsClient
+}
+
+var (
+ storageKeyCacheMu sync.RWMutex
+ storageKeyCache = make(map[string]string)
+)
+
+func (c *ArmClient) getKeyForStorageAccount(ctx context.Context, resourceGroupName, storageAccountName string) (string, bool, error) {
+ cacheIndex := resourceGroupName + "/" + storageAccountName
+ storageKeyCacheMu.RLock()
+ key, ok := storageKeyCache[cacheIndex]
+ storageKeyCacheMu.RUnlock()
+
+ if ok {
+ return key, true, nil
+ }
+
+ storageKeyCacheMu.Lock()
+ defer storageKeyCacheMu.Unlock()
+ key, ok = storageKeyCache[cacheIndex]
+ if !ok {
+ accountKeys, err := c.storageServiceClient.ListKeys(ctx, resourceGroupName, storageAccountName)
+ if utils.ResponseWasNotFound(accountKeys.Response) {
+ return "", false, nil
+ }
+ if err != nil {
+ // We assume this is a transient error rather than a 404 (which is caught above), so assume the
+ // account still exists.
+ return "", true, fmt.Errorf("error retrieving keys for storage account %q: %s", storageAccountName, err)
+ }
+
+ if accountKeys.Keys == nil {
+ return "", false, fmt.Errorf("nil key returned for storage account %q", storageAccountName)
+ }
+
+ keys := *accountKeys.Keys
+ if len(keys) <= 0 {
+ return "", false, fmt.Errorf("no keys returned for storage account %q", storageAccountName)
+ }
+
+ keyPtr := keys[0].Value
+ if keyPtr == nil {
+ return "", false, fmt.Errorf("the first key returned is nil for storage account %q", storageAccountName)
+ }
+
+ key = *keyPtr
+ storageKeyCache[cacheIndex] = key
+ }
+
+ return key, true, nil
+}
+
+func (c *ArmClient) getBlobStorageClientForStorageAccount(ctx context.Context, resourceGroupName, storageAccountName string) (*mainStorage.BlobStorageClient, bool, error) {
+ key, accountExists, err := c.getKeyForStorageAccount(ctx, resourceGroupName, storageAccountName)
+ if err != nil {
+ return nil, accountExists, err
+ }
+ if !accountExists {
+ return nil, false, nil
+ }
+
+ storageClient, err := mainStorage.NewClient(storageAccountName, key, c.environment.StorageEndpointSuffix,
+ "2016-05-31", true)
+ if err != nil {
+ return nil, true, fmt.Errorf("error creating storage client for storage account %q: %s", storageAccountName, err)
+ }
+
+ blobClient := storageClient.GetBlobService()
+ return &blobClient, true, nil
+}
diff --git a/pkg/terraform/exec/plugins/azurestackprivate/provider.go b/pkg/terraform/exec/plugins/azurestackprivate/provider.go
new file mode 100644
index 00000000000..a94ca875e3c
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate/provider.go
@@ -0,0 +1,94 @@
+package azurestackprivate
+
+import (
+ "fmt"
+
+ "github.com/hashicorp/go-azure-helpers/authentication"
+ "github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+ "github.com/hashicorp/terraform-plugin-sdk/terraform"
+)
+
+// Provider returns a terraform.ResourceProvider.
+func Provider() terraform.ResourceProvider {
+ p := &schema.Provider{
+ Schema: map[string]*schema.Schema{
+ "subscription_id": {
+ Type: schema.TypeString,
+ Optional: true,
+ DefaultFunc: schema.EnvDefaultFunc("ARM_SUBSCRIPTION_ID", ""),
+ },
+
+ "client_id": {
+ Type: schema.TypeString,
+ Optional: true,
+ DefaultFunc: schema.EnvDefaultFunc("ARM_CLIENT_ID", ""),
+ },
+
+ "tenant_id": {
+ Type: schema.TypeString,
+ Optional: true,
+ DefaultFunc: schema.EnvDefaultFunc("ARM_TENANT_ID", ""),
+ },
+
+ "arm_endpoint": {
+ Type: schema.TypeString,
+ Required: true,
+ DefaultFunc: schema.EnvDefaultFunc("ARM_ENDPOINT", "public"),
+ },
+
+ // Client Secret specific fields
+ "client_secret": {
+ Type: schema.TypeString,
+ Optional: true,
+ DefaultFunc: schema.EnvDefaultFunc("ARM_CLIENT_SECRET", ""),
+ },
+ },
+
+ DataSourcesMap: map[string]*schema.Resource{},
+
+ ResourcesMap: map[string]*schema.Resource{
+ "azurestackprivate_vhd_blob": resourceArmVHDBlob(),
+ },
+ }
+
+ p.ConfigureFunc = providerConfigure(p)
+
+ return p
+}
+
+func providerConfigure(p *schema.Provider) schema.ConfigureFunc {
+ return func(d *schema.ResourceData) (interface{}, error) {
+ builder := &authentication.Builder{
+ SubscriptionID: d.Get("subscription_id").(string),
+ ClientID: d.Get("client_id").(string),
+ ClientSecret: d.Get("client_secret").(string),
+ TenantID: d.Get("tenant_id").(string),
+ CustomResourceManagerEndpoint: d.Get("arm_endpoint").(string),
+ Environment: "AZURESTACKCLOUD",
+
+ // Feature Toggles
+ SupportsClientSecretAuth: true,
+ }
+
+ config, err := builder.Build()
+ if err != nil {
+ return nil, fmt.Errorf("error building AzureRM Client: %s", err)
+ }
+
+ client, err := getArmClient(config, p.TerraformVersion, true)
+
+ if err != nil {
+ return nil, err
+ }
+
+ client.StopContext = p.StopContext()
+
+ // replaces the context between tests
+ p.MetaReset = func() error {
+ client.StopContext = p.StopContext()
+ return nil
+ }
+
+ return client, nil
+ }
+}
diff --git a/pkg/terraform/exec/plugins/azurestackprivate/resource_vhd_blob.go b/pkg/terraform/exec/plugins/azurestackprivate/resource_vhd_blob.go
new file mode 100644
index 00000000000..ad00a58405b
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate/resource_vhd_blob.go
@@ -0,0 +1,284 @@
+package azurestackprivate
+
+import (
+ "fmt"
+ "log"
+ "os"
+ "runtime"
+ "strings"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/validator"
+ "github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+ "github.com/openshift/azure-sdk-for-go/storage"
+
+ "github.com/openshift/installer/pkg/terraform/exec/plugins/azurestackprivate/upload"
+ "github.com/openshift/installer/pkg/terraform/exec/plugins/azurestackprivate/upload/metadata"
+)
+
+const (
+ // PageBlobPageSize is the size of the page blob in bytes.
+ PageBlobPageSize int64 = 2 * 1024 * 1024
+ apiProfileVersion = "2019-07-07"
+)
+
+func resourceArmVHDBlob() *schema.Resource {
+ return &schema.Resource{
+ Create: resourceArmVHDBlobCreate,
+ Read: resourceArmStorageBlobRead,
+ Exists: resourceArmStorageBlobExists,
+ Delete: resourceArmStorageBlobDelete,
+
+ Schema: map[string]*schema.Schema{
+ "name": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+ "resource_group_name": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+ "storage_account_name": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+ "storage_container_name": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+ "source": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+ "url": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+ },
+ }
+}
+
+func resourceArmVHDBlobCreate(d *schema.ResourceData, meta interface{}) error {
+ armClient := meta.(*ArmClient)
+ ctx := armClient.StopContext
+
+ cont := d.Get("storage_container_name").(string)
+ name := d.Get("name").(string)
+ resourceGroupName := d.Get("resource_group_name").(string)
+ source := d.Get("source").(string)
+ storageAccountName := d.Get("storage_account_name").(string)
+
+ ensureVHDSanity(source)
+ diskStream, err := diskstream.CreateNewDiskStream(source)
+ if err != nil {
+ return err
+ }
+ defer diskStream.Close()
+
+ storageAccountKey, accountExists, err := armClient.getKeyForStorageAccount(ctx, resourceGroupName, storageAccountName)
+ if err != nil {
+ return err
+ }
+ if !accountExists {
+ return fmt.Errorf("storage account %q not found in resource group %q while uploading RHCOS image", storageAccountName, resourceGroupName)
+ }
+
+ blobServiceBaseURL := strings.TrimPrefix(armClient.environment.ResourceManagerEndpoint, "https://management.")
+ storageClient, err := storage.NewClient(storageAccountName, storageAccountKey, blobServiceBaseURL, apiProfileVersion, true)
+ if err != nil {
+ return err
+ }
+ blobClient := storageClient.GetBlobService()
+
+ localMetaData, err := getMetaDataFromLocalVHD(source)
+ if err != nil {
+ return err
+ }
+ var rangesToSkip []*common.IndexRange
+ createBlob(blobClient, cont, name, diskStream.GetSize(), localMetaData)
+
+ uploadableRanges, err := upload.LocateUploadableRanges(diskStream, rangesToSkip, PageBlobPageSize)
+ if err != nil {
+ return err
+ }
+
+ uploadableRanges, err = upload.DetectEmptyRanges(diskStream, uploadableRanges)
+ if err != nil {
+ return err
+ }
+
+ cxt := &upload.DiskUploadContext{
+ VhdStream: diskStream,
+ UploadableRanges: uploadableRanges,
+ AlreadyProcessedBytes: common.TotalRangeLength(rangesToSkip),
+ BlobServiceClient: blobClient,
+ ContainerName: cont,
+ BlobName: name,
+ Parallelism: 8 * runtime.NumCPU(),
+ Resume: false,
+ }
+ log.Printf("[INFO] Creating blob %q in storage account %q", name, storageAccountName)
+
+ err = upload.Upload(cxt)
+ if err != nil {
+ return err
+ }
+
+ // Delete the VHD because we just unzipped a 16GB file in a dir the user is
+ // probably unaware of.
+ err = os.Remove(source)
+ if err != nil {
+ log.Printf("[WARN] Unable to delete temp file %s after upload, please delete manually: %s", source, err.Error())
+ }
+
+ d.SetId(name)
+ return resourceArmStorageBlobRead(d, meta)
+}
+
+func getMetaDataFromLocalVHD(vhdPath string) (*metadata.MetaData, error) {
+ fileStat, err := getFileStat(vhdPath)
+ if err != nil {
+ return nil, err
+ }
+
+ fileMetaData := &metadata.FileMetaData{
+ FileName: fileStat.Name(),
+ FileSize: fileStat.Size(),
+ LastModifiedTime: fileStat.ModTime(),
+ }
+
+ diskStream, err := diskstream.CreateNewDiskStream(vhdPath)
+ if err != nil {
+ return nil, err
+ }
+ defer diskStream.Close()
+ return &metadata.MetaData{
+ FileMetaData: fileMetaData,
+ }, nil
+}
+
+// getFileStat returns os.FileInfo of a file.
+//
+func getFileStat(filePath string) (os.FileInfo, error) {
+ fd, err := os.Open(filePath)
+ if err != nil {
+ return nil, fmt.Errorf("fileMetaData.getFileStat: %v", err)
+ }
+ defer fd.Close()
+ return fd.Stat()
+}
+
+// createBlob creates a page blob of specific size and sets custom metadata
+// The parameter client is the Azure blob service client, parameter containerName is the name of an existing container
+// in which the page blob needs to be created, parameter blobName is name for the new page blob, size is the size of
+// the new page blob in bytes and parameter vhdMetaData is the custom metadata to be associacted with the page blob
+//
+func createBlob(client storage.BlobStorageClient, containerName, blobName string, size int64, vhdMetaData *metadata.MetaData) {
+ if err := client.PutPageBlob(containerName, blobName, size, nil); err != nil {
+ log.Fatal(err)
+ }
+ m, _ := vhdMetaData.ToMap()
+ if err := client.SetBlobMetadata(containerName, blobName, m, make(map[string]string)); err != nil {
+ log.Fatal(err)
+ }
+}
+
+// ensureVHDSanity ensure is VHD is valid for Azure.
+//
+func ensureVHDSanity(localVHDPath string) {
+ if err := validator.ValidateVhd(localVHDPath); err != nil {
+ log.Fatal(err)
+ }
+
+ if err := validator.ValidateVhdSize(localVHDPath); err != nil {
+ log.Fatal(err)
+ }
+}
+
+func resourceArmStorageBlobRead(d *schema.ResourceData, meta interface{}) error {
+ armClient := meta.(*ArmClient)
+ ctx := armClient.StopContext
+
+ resourceGroupName := d.Get("resource_group_name").(string)
+ storageAccountName := d.Get("storage_account_name").(string)
+
+ blobClient, accountExists, err := armClient.getBlobStorageClientForStorageAccount(ctx, resourceGroupName, storageAccountName)
+ if err != nil {
+ return err
+ }
+ if !accountExists {
+ log.Printf("[DEBUG] Storage account %q not found, removing blob %q from state", storageAccountName, d.Id())
+ d.SetId("")
+ return nil
+ }
+
+ exists, err := resourceArmStorageBlobExists(d, meta)
+ if err != nil {
+ return err
+ }
+
+ if !exists {
+ // Exists already removed this from state
+ return nil
+ }
+
+ name := d.Get("name").(string)
+ storageContainerName := d.Get("storage_container_name").(string)
+
+ container := blobClient.GetContainerReference(storageContainerName)
+ blob := container.GetBlobReference(name)
+ url := blob.GetURL()
+ if url == "" {
+ log.Printf("[INFO] URL for %q is empty", name)
+ }
+ d.Set("url", url)
+
+ return nil
+}
+
+func resourceArmStorageBlobExists(d *schema.ResourceData, meta interface{}) (bool, error) {
+ armClient := meta.(*ArmClient)
+ ctx := armClient.StopContext
+
+ resourceGroupName := d.Get("resource_group_name").(string)
+ storageAccountName := d.Get("storage_account_name").(string)
+
+ blobClient, accountExists, err := armClient.getBlobStorageClientForStorageAccount(ctx, resourceGroupName, storageAccountName)
+ if err != nil {
+ return false, err
+ }
+ if !accountExists {
+ log.Printf("[DEBUG] Storage account %q not found, removing blob %q from state", storageAccountName, d.Id())
+ d.SetId("")
+ return false, nil
+ }
+
+ name := d.Get("name").(string)
+ storageContainerName := d.Get("storage_container_name").(string)
+
+ log.Printf("[INFO] Checking for existence of storage blob %q.", name)
+ container := blobClient.GetContainerReference(storageContainerName)
+ blob := container.GetBlobReference(name)
+ exists, err := blob.Exists()
+ if err != nil {
+ return false, fmt.Errorf("error testing existence of storage blob %q: %s", name, err)
+ }
+
+ if !exists {
+ log.Printf("[INFO] Storage blob %q no longer exists, removing from state...", name)
+ d.SetId("")
+ }
+
+ return exists, nil
+}
+
+// We do not use this Terraform provider for deletion but this implementation is required.
+func resourceArmStorageBlobDelete(d *schema.ResourceData, meta interface{}) error {
+ return nil
+}
diff --git a/pkg/terraform/exec/plugins/azurestackprivate/upload/detectEmptyRanges.go b/pkg/terraform/exec/plugins/azurestackprivate/upload/detectEmptyRanges.go
new file mode 100644
index 00000000000..f7d33aaa0f0
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate/upload/detectEmptyRanges.go
@@ -0,0 +1,114 @@
+package upload
+
+import (
+ "fmt"
+ "io"
+ "math"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+)
+
+// DataWithRange type describes a range and data associated with the range.
+//
+type DataWithRange struct {
+ Range *common.IndexRange
+ Data []byte
+}
+
+// DetectEmptyRanges read the ranges identified by the parameter uploadableRanges from the disk stream, detect the empty
+// ranges and update the uploadableRanges slice by removing the empty ranges. This method returns the updated ranges.
+// The empty range detection required only for Fixed disk, if the stream is a expandable disk stream this method simply
+// returns the parameter uploadableRanges as it is.
+//
+func DetectEmptyRanges(diskStream *diskstream.DiskStream, uploadableRanges []*common.IndexRange) ([]*common.IndexRange, error) {
+ if diskStream.GetDiskType() != footer.DiskTypeFixed {
+ return uploadableRanges, nil
+ }
+
+ fmt.Println("\nDetecting empty ranges..")
+ totalRangesCount := len(uploadableRanges)
+ lastIndex := int32(-1)
+ emptyRangesCount := int32(0)
+ bits := make([]byte, int32(math.Ceil(float64(totalRangesCount)/float64(8))))
+ bmap := bitmap.NewBitMapFromByteSliceCopy(bits)
+ indexChan, errChan := LocateNonEmptyRangeIndices(diskStream, uploadableRanges)
+L:
+ for {
+ select {
+ case index, ok := <-indexChan:
+ if !ok {
+ break L
+ }
+ bmap.Set(index, true)
+ emptyRangesCount += index - lastIndex - 1
+ lastIndex = index
+ fmt.Printf("\r Empty ranges : %d/%d", emptyRangesCount, totalRangesCount)
+ case err := <-errChan:
+ return nil, err
+ }
+ }
+
+ // Remove empty ranges from the uploadable ranges slice.
+ i := int32(0)
+ for j := 0; j < totalRangesCount; j++ {
+ if set, _ := bmap.Get(int32(j)); set {
+ uploadableRanges[i] = uploadableRanges[j]
+ i++
+ }
+ }
+ uploadableRanges = uploadableRanges[:i]
+ return uploadableRanges, nil
+}
+
+// LocateNonEmptyRangeIndices scan the given range and detects a subset of ranges which contains data.
+// It reports the indices of non-empty ranges via a channel. This method returns two channels, an int channel - used
+// to report the non-empty range indices and error channel - used to report any error while performing empty detection.
+// int channel will be closed on a successful completion, the caller must not expect any more value in the
+// int channel if the error channel is signaled.
+//
+func LocateNonEmptyRangeIndices(stream *diskstream.DiskStream, ranges []*common.IndexRange) (<-chan int32, <-chan error) {
+ indexChan := make(chan int32, 0)
+ errorChan := make(chan error, 0)
+ go func() {
+ count := int64(-1)
+ var buf []byte
+ for index, r := range ranges {
+ if count != r.Length() {
+ count = r.Length()
+ buf = make([]byte, count)
+ }
+
+ _, err := stream.Seek(r.Start, 0)
+ if err != nil {
+ errorChan <- err
+ return
+ }
+ _, err = io.ReadFull(stream, buf)
+ if err != nil {
+ errorChan <- err
+ return
+ }
+ if !isAllZero(buf) {
+ indexChan <- int32(index)
+ }
+ }
+ close(indexChan)
+ }()
+ return indexChan, errorChan
+}
+
+// isAllZero returns true if the given byte slice contain all zeros
+//
+func isAllZero(buf []byte) bool {
+ l := len(buf)
+ j := 0
+ for ; j < l; j++ {
+ if buf[j] != byte(0) {
+ break
+ }
+ }
+ return j == l
+}
diff --git a/pkg/terraform/exec/plugins/azurestackprivate/upload/metadata/metaData.go b/pkg/terraform/exec/plugins/azurestackprivate/upload/metadata/metaData.go
new file mode 100644
index 00000000000..373fbf13dbe
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate/upload/metadata/metaData.go
@@ -0,0 +1,190 @@
+package metadata
+
+import (
+ "bytes"
+ "crypto/md5"
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "io"
+ "os"
+ "time"
+
+ "github.com/Microsoft/azure-vhd-utils/upload/progress"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream"
+ "github.com/openshift/azure-sdk-for-go/storage"
+)
+
+// The key of the page blob metadata collection entry holding VHD metadata as json.
+//
+const metaDataKey = "diskmetadata"
+
+// MetaData is the type representing metadata associated with an Azure page blob holding the VHD.
+// This will be stored as a JSON string in the page blob metadata collection with key 'diskmetadata'.
+//
+type MetaData struct {
+ FileMetaData *FileMetaData `json:"fileMetaData"`
+}
+
+// FileMetaData represents the metadata of a VHD file.
+//
+type FileMetaData struct {
+ FileName string `json:"fileName"`
+ FileSize int64 `json:"fileSize"`
+ VHDSize int64 `json:"vhdSize"`
+ LastModifiedTime time.Time `json:"lastModifiedTime"`
+ MD5Hash []byte `json:"md5Hash"` // Marshal will encodes []byte as a base64-encoded string
+}
+
+// ToJSON returns MetaData as a json string.
+//
+func (m *MetaData) ToJSON() (string, error) {
+ b, err := json.Marshal(m)
+ if err != nil {
+ return "", err
+ }
+ return string(b), nil
+}
+
+// ToMap returns the map representation of the MetaData which can be stored in the page blob metadata colleciton
+//
+func (m *MetaData) ToMap() (map[string]string, error) {
+ v, err := m.ToJSON()
+ if err != nil {
+ return nil, err
+ }
+
+ return map[string]string{metaDataKey: v}, nil
+}
+
+// NewMetaDataFromLocalVHD creates a MetaData instance that should be associated with the page blob
+// holding the VHD. The parameter vhdPath is the path to the local VHD.
+//
+func NewMetaDataFromLocalVHD(vhdPath string) (*MetaData, error) {
+ fileStat, err := getFileStat(vhdPath)
+ if err != nil {
+ return nil, err
+ }
+
+ fileMetaData := &FileMetaData{
+ FileName: fileStat.Name(),
+ FileSize: fileStat.Size(),
+ LastModifiedTime: fileStat.ModTime(),
+ }
+
+ diskStream, err := diskstream.CreateNewDiskStream(vhdPath)
+ if err != nil {
+ return nil, err
+ }
+ defer diskStream.Close()
+ fileMetaData.VHDSize = diskStream.GetSize()
+ // fileMetaData.MD5Hash, err = calculateMD5Hash(diskStream)
+ // if err != nil {
+ // return nil, err
+ // }
+
+ return &MetaData{
+ FileMetaData: fileMetaData,
+ }, nil
+}
+
+// NewMetadataFromBlob returns MetaData instance associated with a Azure page blob, if there is no
+// MetaData associated with the blob it returns nil value for MetaData
+//
+func NewMetadataFromBlob(blobClient storage.BlobStorageClient, containerName, blobName string) (*MetaData, error) {
+ allMetadata, err := blobClient.GetBlobMetadata(containerName, blobName)
+ if err != nil {
+ return nil, fmt.Errorf("failed to fetch blob metadata: %v", err)
+ }
+ m, ok := allMetadata[metaDataKey]
+ if !ok {
+ return nil, nil
+ }
+
+ b := []byte(m)
+ metadata := MetaData{}
+ if err := json.Unmarshal(b, &metadata); err != nil {
+ return nil, fmt.Errorf("failed to deserialize blob metadata with key %s: %v", metaDataKey, err)
+ }
+ return &metadata, nil
+}
+
+// CompareMetaData compares the MetaData associated with the remote page blob and local VHD file. If both metadata
+// are same this method returns an empty error slice else a non-empty error slice with each error describing
+// the metadata entry that mismatched.
+//
+func CompareMetaData(remote, local *MetaData) []error {
+ var metadataErrors = make([]error, 0)
+ if !bytes.Equal(remote.FileMetaData.MD5Hash, local.FileMetaData.MD5Hash) {
+ metadataErrors = append(metadataErrors,
+ fmt.Errorf("MD5 hash of VHD file in Azure blob storage (%v) and local VHD file (%v) does not match",
+ base64.StdEncoding.EncodeToString(remote.FileMetaData.MD5Hash),
+ base64.StdEncoding.EncodeToString(local.FileMetaData.MD5Hash)))
+ }
+
+ if remote.FileMetaData.VHDSize != local.FileMetaData.VHDSize {
+ metadataErrors = append(metadataErrors,
+ fmt.Errorf("logical size of the VHD file in Azure blob storage (%d) and local VHD file (%d) does not match",
+ remote.FileMetaData.VHDSize, local.FileMetaData.VHDSize))
+ }
+
+ if remote.FileMetaData.FileSize != local.FileMetaData.FileSize {
+ metadataErrors = append(metadataErrors,
+ fmt.Errorf("size of the VHD file in Azure blob storage (%d) and local VHD file (%d) does not match",
+ remote.FileMetaData.FileSize, local.FileMetaData.FileSize))
+ }
+
+ if remote.FileMetaData.LastModifiedTime != local.FileMetaData.LastModifiedTime {
+ metadataErrors = append(metadataErrors,
+ fmt.Errorf("last modified time of the VHD file in Azure blob storage (%v) and local VHD file (%v) does not match",
+ remote.FileMetaData.LastModifiedTime, local.FileMetaData.LastModifiedTime))
+ }
+
+ if remote.FileMetaData.FileName != local.FileMetaData.FileName {
+ metadataErrors = append(metadataErrors,
+ fmt.Errorf("full name of the VHD file in Azure blob storage (%s) and local VHD file (%s) does not match",
+ remote.FileMetaData.FileName, local.FileMetaData.FileName))
+ }
+
+ return metadataErrors
+}
+
+// getFileStat returns os.FileInfo of a file.
+//
+func getFileStat(filePath string) (os.FileInfo, error) {
+ fd, err := os.Open(filePath)
+ if err != nil {
+ return nil, fmt.Errorf("fileMetaData.getFileStat: %v", err)
+ }
+ defer fd.Close()
+ return fd.Stat()
+}
+
+// calculateMD5Hash compute the MD5 checksum of a disk stream, it writes the compute progress in stdout
+// If there is an error in reading file, then the MD5 compute will stop and it return error.
+//
+func calculateMD5Hash(diskStream *diskstream.DiskStream) ([]byte, error) {
+ progressStream := progress.NewReaderWithProgress(diskStream, diskStream.GetSize(), 1*time.Second)
+ defer progressStream.Close()
+
+ go func() {
+ s := time.Time{}
+ fmt.Println("Computing MD5 Checksum..")
+ for progressRecord := range progressStream.ProgressChan {
+ t := s.Add(progressRecord.RemainingDuration)
+ fmt.Printf("\r Completed: %3d%% RemainingTime: %02dh:%02dm:%02ds Throughput: %d MB/sec",
+ int(progressRecord.PercentComplete),
+ t.Hour(), t.Minute(), t.Second(),
+ int(progressRecord.AverageThroughputMbPerSecond),
+ )
+ }
+ }()
+
+ h := md5.New()
+ buf := make([]byte, 2097152) // 2 MB staging buffer
+ _, err := io.CopyBuffer(h, progressStream, buf)
+ if err != nil {
+ return nil, err
+ }
+ return h.Sum(nil), nil
+}
diff --git a/pkg/terraform/exec/plugins/azurestackprivate/upload/upload.go b/pkg/terraform/exec/plugins/azurestackprivate/upload/upload.go
new file mode 100644
index 00000000000..2852b49932c
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate/upload/upload.go
@@ -0,0 +1,193 @@
+package upload
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "time"
+
+ "github.com/Microsoft/azure-vhd-utils/upload/concurrent"
+ "github.com/Microsoft/azure-vhd-utils/upload/progress"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream"
+ "github.com/openshift/azure-sdk-for-go/storage"
+)
+
+// DiskUploadContext type describes VHD upload context, this includes the disk stream to read from, the ranges of
+// the stream to read, the destination blob and it's container, the client to communicate with Azure storage and
+// the number of parallel go-routines to use for upload.
+//
+type DiskUploadContext struct {
+ VhdStream *diskstream.DiskStream // The stream whose ranges needs to be uploaded
+ AlreadyProcessedBytes int64 // The size in bytes already uploaded
+ UploadableRanges []*common.IndexRange // The subset of stream ranges to be uploaded
+ BlobServiceClient storage.BlobStorageClient // The client to make Azure blob service API calls
+ ContainerName string // The container in which page blob resides
+ BlobName string // The destination page blob name
+ Parallelism int // The number of concurrent goroutines to be used for upload
+ Resume bool // Indicate whether this is a new or resuming upload
+ MD5Hash []byte // MD5Hash to be set in the page blob properties once upload finishes
+}
+
+// oneMB is one MegaByte
+//
+const oneMB = float64(1048576)
+
+// Upload uploads the disk ranges described by the parameter cxt, this parameter describes the disk stream to
+// read from, the ranges of the stream to read, the destination blob and it's container, the client to communicate
+// with Azure storage and the number of parallel go-routines to use for upload.
+//
+func Upload(cxt *DiskUploadContext) error {
+ // Get the channel that contains stream of disk data to upload
+ dataWithRangeChan, streamReadErrChan := GetDataWithRanges(cxt.VhdStream, cxt.UploadableRanges)
+
+ // The channel to send upload request to load-balancer
+ requtestChan := make(chan *concurrent.Request, 0)
+
+ // Prepare and start the load-balancer that load request across 'cxt.Parallelism' workers
+ loadBalancer := concurrent.NewBalancer(cxt.Parallelism)
+ loadBalancer.Init()
+ workerErrorChan, allWorkersFinishedChan := loadBalancer.Run(requtestChan)
+
+ // Calculate the actual size of the data to upload
+ uploadSizeInBytes := int64(0)
+ for _, r := range cxt.UploadableRanges {
+ uploadSizeInBytes += r.Length()
+ }
+ fmt.Printf("\nEffective upload size: %.2f MB (from %.2f MB originally)", float64(uploadSizeInBytes)/oneMB, float64(cxt.VhdStream.GetSize())/oneMB)
+
+ // Prepare and start the upload progress tracker
+ uploadProgress := progress.NewStatus(cxt.Parallelism, cxt.AlreadyProcessedBytes, uploadSizeInBytes, progress.NewComputestateDefaultSize())
+ progressChan := uploadProgress.Run()
+
+ // read progress status from progress tracker and print it
+ go readAndPrintProgress(progressChan, cxt.Resume)
+
+ // listen for errors reported by workers and print it
+ var allWorkSucceeded = true
+ go func() {
+ for {
+ fmt.Println(<-workerErrorChan)
+ allWorkSucceeded = false
+ }
+ }()
+
+ var err error
+L:
+ for {
+ select {
+ case dataWithRange, ok := <-dataWithRangeChan:
+ if !ok {
+ close(requtestChan)
+ break L
+ }
+
+ // Create work request
+ //
+ req := &concurrent.Request{
+ Work: func() error {
+ err := cxt.BlobServiceClient.PutPage(cxt.ContainerName,
+ cxt.BlobName,
+ dataWithRange.Range.Start,
+ dataWithRange.Range.End,
+ storage.PageWriteTypeUpdate,
+ dataWithRange.Data,
+ nil)
+ if err == nil {
+ uploadProgress.ReportBytesProcessedCount(dataWithRange.Range.Length())
+ }
+ return err
+ },
+ ShouldRetry: func(e error) bool {
+ return true
+ },
+ ID: dataWithRange.Range.String(),
+ }
+
+ // Send work request to load balancer for processing
+ //
+ requtestChan <- req
+ case err = <-streamReadErrChan:
+ close(requtestChan)
+ loadBalancer.TearDownWorkers()
+ break L
+ }
+ }
+
+ <-allWorkersFinishedChan
+ uploadProgress.Close()
+
+ if !allWorkSucceeded {
+ err = errors.New("\nUpload Incomplete: Some blocks of the VHD failed to upload, rerun the command to upload those blocks")
+ }
+
+ if err == nil {
+ fmt.Printf("\r Completed: %3d%% [%10.2f MB] RemainingTime: %02dh:%02dm:%02ds Throughput: %d Mb/sec %2c ",
+ 100,
+ float64(uploadSizeInBytes)/oneMB,
+ 0, 0, 0,
+ 0, ' ')
+
+ }
+ return err
+}
+
+// GetDataWithRanges with start reading and streaming the ranges from the disk identified by the parameter ranges.
+// It returns two channels, a data channel to stream the disk ranges and a channel to send any error while reading
+// the disk. On successful completion the data channel will be closed. the caller must not expect any more value in
+// the data channel if the error channel is signaled.
+//
+func GetDataWithRanges(stream *diskstream.DiskStream, ranges []*common.IndexRange) (<-chan *DataWithRange, <-chan error) {
+ dataWithRangeChan := make(chan *DataWithRange, 0)
+ errorChan := make(chan error, 0)
+ go func() {
+ for _, r := range ranges {
+ dataWithRange := &DataWithRange{
+ Range: r,
+ Data: make([]byte, r.Length()),
+ }
+ _, err := stream.Seek(r.Start, 0)
+ if err != nil {
+ errorChan <- err
+ return
+ }
+ _, err = io.ReadFull(stream, dataWithRange.Data)
+ if err != nil {
+ errorChan <- err
+ return
+ }
+ dataWithRangeChan <- dataWithRange
+ }
+ close(dataWithRangeChan)
+ }()
+ return dataWithRangeChan, errorChan
+}
+
+// readAndPrintProgress reads the progress records from the given progress channel and output it. It reads the
+// progress record until the channel is closed.
+//
+func readAndPrintProgress(progressChan <-chan *progress.Record, resume bool) {
+ var spinChars = [4]rune{'\\', '|', '/', '-'}
+ s := time.Time{}
+ if resume {
+ fmt.Println("\nResuming VHD upload..")
+ } else {
+ fmt.Println("\nUploading the VHD..")
+ }
+
+ i := 0
+ for progressRecord := range progressChan {
+ if i == 4 {
+ i = 0
+ }
+ t := s.Add(progressRecord.RemainingDuration)
+ fmt.Printf("\r Completed: %3d%% [%10.2f MB] RemainingTime: %02dh:%02dm:%02ds Throughput: %d Mb/sec %2c ",
+ int(progressRecord.PercentComplete),
+ float64(progressRecord.BytesProcessed)/oneMB,
+ t.Hour(), t.Minute(), t.Second(),
+ int(progressRecord.AverageThroughputMbPerSecond),
+ spinChars[i],
+ )
+ i++
+ }
+}
diff --git a/pkg/terraform/exec/plugins/azurestackprivate/upload/uploadableRanges.go b/pkg/terraform/exec/plugins/azurestackprivate/upload/uploadableRanges.go
new file mode 100644
index 00000000000..3c2d07e4027
--- /dev/null
+++ b/pkg/terraform/exec/plugins/azurestackprivate/upload/uploadableRanges.go
@@ -0,0 +1,37 @@
+package upload
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream"
+)
+
+// LocateUploadableRanges detects the uploadable ranges in a VHD stream, size of each range is at most pageSizeInBytes.
+//
+// This method reads the existing ranges A from the disk stream, creates a new set of ranges B from A by removing the
+// ranges identified by the parameter rangesToSkip, returns new set of ranges C (with each range of size at most
+// pageSizeInBytes) by merging adjacent ranges in B or splitting ranges in B.
+//
+// Note that this method will not check whether ranges of a fixed disk contains zeros, hence inorder to filter out such
+// ranges from the uploadable ranges, caller must use LocateNonEmptyRangeIndices method.
+//
+func LocateUploadableRanges(stream *diskstream.DiskStream, rangesToSkip []*common.IndexRange, pageSizeInBytes int64) ([]*common.IndexRange, error) {
+ var err error
+ var diskRanges = make([]*common.IndexRange, 0)
+ stream.EnumerateExtents(func(ext *diskstream.StreamExtent, extErr error) bool {
+ if extErr != nil {
+ err = extErr
+ return false
+ }
+
+ diskRanges = append(diskRanges, ext.Range)
+ return true
+ })
+
+ if err != nil {
+ return nil, err
+ }
+
+ diskRanges = common.SubtractRanges(diskRanges, rangesToSkip)
+ diskRanges = common.ChunkRangesBySize(diskRanges, pageSizeInBytes)
+ return diskRanges, nil
+}
diff --git a/pkg/tfvars/azure/azure.go b/pkg/tfvars/azure/azure.go
index 821d839349d..3ee85a9ac52 100644
--- a/pkg/tfvars/azure/azure.go
+++ b/pkg/tfvars/azure/azure.go
@@ -2,12 +2,14 @@ package azure
import (
"encoding/json"
+ "strings"
"github.com/Azure/go-autorest/autorest/to"
"github.com/pkg/errors"
azureprovider "sigs.k8s.io/cluster-api-provider-azure/pkg/apis/azureprovider/v1beta1"
+ "github.com/openshift/installer/pkg/tfvars/internal/cache"
"github.com/openshift/installer/pkg/types"
"github.com/openshift/installer/pkg/types/azure"
"github.com/openshift/installer/pkg/types/azure/defaults"
@@ -21,6 +23,7 @@ type Auth struct {
TenantID string `json:"azure_tenant_id,omitempty"`
}
+// config is used by both Azure and Azure Stack terraform configs
type config struct {
Auth `json:",inline"`
Environment string `json:"azure_environment"`
@@ -32,6 +35,7 @@ type config struct {
VolumeType string `json:"azure_master_root_volume_type"`
VolumeSize int32 `json:"azure_master_root_volume_size"`
ImageURL string `json:"azure_image_url,omitempty"`
+ ImagePath string `json:"azure_image_path,omitempty"`
Region string `json:"azure_region,omitempty"`
BaseDomainResourceGroupName string `json:"azure_base_domain_resource_group_name,omitempty"`
ResourceGroupName string `json:"azure_resource_group_name"`
@@ -76,6 +80,14 @@ func TFVars(sources TFVarsSources) ([]byte, error) {
return nil, errors.Wrap(err, "could not determine Azure environment to use for Terraform")
}
+ var imagePath string
+ if sources.CloudName == azure.StackCloud {
+ imagePath, err = checkImagePath(sources.ImageURL, sources.ARMEndpoint)
+ if err != nil {
+ return nil, err
+ }
+ }
+
cfg := &config{
Auth: sources.Auth,
Environment: environment,
@@ -86,6 +98,7 @@ func TFVars(sources TFVarsSources) ([]byte, error) {
MasterAvailabilityZones: masterAvailabilityZones,
VolumeType: masterConfig.OSDisk.ManagedDisk.StorageAccountType,
VolumeSize: masterConfig.OSDisk.DiskSizeGB,
+ ImagePath: imagePath,
ImageURL: sources.ImageURL,
Private: sources.Publish == types.InternalPublishingStrategy,
OutboundUDR: sources.OutboundType == azure.UserDefinedRoutingOutboundType,
@@ -119,3 +132,18 @@ func environment(cloudName azure.CloudEnvironment) (string, error) {
return "", errors.Errorf("unsupported cloud name %q", cloudName)
}
}
+
+func checkImagePath(imageURL, armEndpoint string) (string, error) {
+ storageBaseURL := strings.TrimPrefix(armEndpoint, "https://management.")
+
+ // If the URL for the image is in the ASH environment we don't want to upload a local VHD.
+ if strings.Contains(imageURL, storageBaseURL) {
+ return "", nil
+ }
+
+ cachedImage, err := cache.DownloadImageFile(imageURL)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to use cached Azure Stack RHCOS image")
+ }
+ return cachedImage, nil
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/compute/mgmt/compute/models.go b/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/compute/mgmt/compute/models.go
new file mode 100644
index 00000000000..5262db5d725
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/compute/mgmt/compute/models.go
@@ -0,0 +1,1002 @@
+// +build go1.9
+
+// Copyright 2021 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This code was auto-generated by:
+// github.com/Azure/azure-sdk-for-go/tools/profileBuilder
+
+package compute
+
+import (
+ "context"
+
+ original "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute"
+)
+
+const (
+ DefaultBaseURI = original.DefaultBaseURI
+)
+
+type AccessLevel = original.AccessLevel
+
+const (
+ None AccessLevel = original.None
+ Read AccessLevel = original.Read
+)
+
+type CachingTypes = original.CachingTypes
+
+const (
+ CachingTypesNone CachingTypes = original.CachingTypesNone
+ CachingTypesReadOnly CachingTypes = original.CachingTypesReadOnly
+ CachingTypesReadWrite CachingTypes = original.CachingTypesReadWrite
+)
+
+type ComponentNames = original.ComponentNames
+
+const (
+ MicrosoftWindowsShellSetup ComponentNames = original.MicrosoftWindowsShellSetup
+)
+
+type DiskCreateOption = original.DiskCreateOption
+
+const (
+ Attach DiskCreateOption = original.Attach
+ Copy DiskCreateOption = original.Copy
+ Empty DiskCreateOption = original.Empty
+ FromImage DiskCreateOption = original.FromImage
+ Import DiskCreateOption = original.Import
+)
+
+type DiskCreateOptionTypes = original.DiskCreateOptionTypes
+
+const (
+ DiskCreateOptionTypesAttach DiskCreateOptionTypes = original.DiskCreateOptionTypesAttach
+ DiskCreateOptionTypesEmpty DiskCreateOptionTypes = original.DiskCreateOptionTypesEmpty
+ DiskCreateOptionTypesFromImage DiskCreateOptionTypes = original.DiskCreateOptionTypesFromImage
+)
+
+type IPVersion = original.IPVersion
+
+const (
+ IPv4 IPVersion = original.IPv4
+ IPv6 IPVersion = original.IPv6
+)
+
+type InstanceViewTypes = original.InstanceViewTypes
+
+const (
+ InstanceView InstanceViewTypes = original.InstanceView
+)
+
+type IntervalInMins = original.IntervalInMins
+
+const (
+ FiveMins IntervalInMins = original.FiveMins
+ SixtyMins IntervalInMins = original.SixtyMins
+ ThirtyMins IntervalInMins = original.ThirtyMins
+ ThreeMins IntervalInMins = original.ThreeMins
+)
+
+type MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypes
+
+const (
+ MaintenanceOperationResultCodeTypesMaintenanceAborted MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesMaintenanceAborted
+ MaintenanceOperationResultCodeTypesMaintenanceCompleted MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesMaintenanceCompleted
+ MaintenanceOperationResultCodeTypesNone MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesNone
+ MaintenanceOperationResultCodeTypesRetryLater MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesRetryLater
+)
+
+type OperatingSystemStateTypes = original.OperatingSystemStateTypes
+
+const (
+ Generalized OperatingSystemStateTypes = original.Generalized
+ Specialized OperatingSystemStateTypes = original.Specialized
+)
+
+type OperatingSystemTypes = original.OperatingSystemTypes
+
+const (
+ Linux OperatingSystemTypes = original.Linux
+ Windows OperatingSystemTypes = original.Windows
+)
+
+type PassNames = original.PassNames
+
+const (
+ OobeSystem PassNames = original.OobeSystem
+)
+
+type ProtocolTypes = original.ProtocolTypes
+
+const (
+ HTTP ProtocolTypes = original.HTTP
+ HTTPS ProtocolTypes = original.HTTPS
+)
+
+type ResourceIdentityType = original.ResourceIdentityType
+
+const (
+ ResourceIdentityTypeNone ResourceIdentityType = original.ResourceIdentityTypeNone
+ ResourceIdentityTypeSystemAssigned ResourceIdentityType = original.ResourceIdentityTypeSystemAssigned
+ ResourceIdentityTypeSystemAssignedUserAssigned ResourceIdentityType = original.ResourceIdentityTypeSystemAssignedUserAssigned
+ ResourceIdentityTypeUserAssigned ResourceIdentityType = original.ResourceIdentityTypeUserAssigned
+)
+
+type ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleType
+
+const (
+ ResourceSkuCapacityScaleTypeAutomatic ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeAutomatic
+ ResourceSkuCapacityScaleTypeManual ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeManual
+ ResourceSkuCapacityScaleTypeNone ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeNone
+)
+
+type ResourceSkuRestrictionsReasonCode = original.ResourceSkuRestrictionsReasonCode
+
+const (
+ NotAvailableForSubscription ResourceSkuRestrictionsReasonCode = original.NotAvailableForSubscription
+ QuotaID ResourceSkuRestrictionsReasonCode = original.QuotaID
+)
+
+type ResourceSkuRestrictionsType = original.ResourceSkuRestrictionsType
+
+const (
+ Location ResourceSkuRestrictionsType = original.Location
+ Zone ResourceSkuRestrictionsType = original.Zone
+)
+
+type RollingUpgradeActionType = original.RollingUpgradeActionType
+
+const (
+ Cancel RollingUpgradeActionType = original.Cancel
+ Start RollingUpgradeActionType = original.Start
+)
+
+type RollingUpgradeStatusCode = original.RollingUpgradeStatusCode
+
+const (
+ Cancelled RollingUpgradeStatusCode = original.Cancelled
+ Completed RollingUpgradeStatusCode = original.Completed
+ Faulted RollingUpgradeStatusCode = original.Faulted
+ RollingForward RollingUpgradeStatusCode = original.RollingForward
+)
+
+type SettingNames = original.SettingNames
+
+const (
+ AutoLogon SettingNames = original.AutoLogon
+ FirstLogonCommands SettingNames = original.FirstLogonCommands
+)
+
+type StatusLevelTypes = original.StatusLevelTypes
+
+const (
+ Error StatusLevelTypes = original.Error
+ Info StatusLevelTypes = original.Info
+ Warning StatusLevelTypes = original.Warning
+)
+
+type StorageAccountTypes = original.StorageAccountTypes
+
+const (
+ PremiumLRS StorageAccountTypes = original.PremiumLRS
+ StandardLRS StorageAccountTypes = original.StandardLRS
+)
+
+type UpgradeMode = original.UpgradeMode
+
+const (
+ Automatic UpgradeMode = original.Automatic
+ Manual UpgradeMode = original.Manual
+ Rolling UpgradeMode = original.Rolling
+)
+
+type UpgradeOperationInvoker = original.UpgradeOperationInvoker
+
+const (
+ Platform UpgradeOperationInvoker = original.Platform
+ Unknown UpgradeOperationInvoker = original.Unknown
+ User UpgradeOperationInvoker = original.User
+)
+
+type UpgradeState = original.UpgradeState
+
+const (
+ UpgradeStateCancelled UpgradeState = original.UpgradeStateCancelled
+ UpgradeStateCompleted UpgradeState = original.UpgradeStateCompleted
+ UpgradeStateFaulted UpgradeState = original.UpgradeStateFaulted
+ UpgradeStateRollingForward UpgradeState = original.UpgradeStateRollingForward
+)
+
+type VirtualMachineEvictionPolicyTypes = original.VirtualMachineEvictionPolicyTypes
+
+const (
+ Deallocate VirtualMachineEvictionPolicyTypes = original.Deallocate
+ Delete VirtualMachineEvictionPolicyTypes = original.Delete
+)
+
+type VirtualMachinePriorityTypes = original.VirtualMachinePriorityTypes
+
+const (
+ Low VirtualMachinePriorityTypes = original.Low
+ Regular VirtualMachinePriorityTypes = original.Regular
+)
+
+type VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleType
+
+const (
+ VirtualMachineScaleSetSkuScaleTypeAutomatic VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleTypeAutomatic
+ VirtualMachineScaleSetSkuScaleTypeNone VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleTypeNone
+)
+
+type VirtualMachineSizeTypes = original.VirtualMachineSizeTypes
+
+const (
+ BasicA0 VirtualMachineSizeTypes = original.BasicA0
+ BasicA1 VirtualMachineSizeTypes = original.BasicA1
+ BasicA2 VirtualMachineSizeTypes = original.BasicA2
+ BasicA3 VirtualMachineSizeTypes = original.BasicA3
+ BasicA4 VirtualMachineSizeTypes = original.BasicA4
+ StandardA0 VirtualMachineSizeTypes = original.StandardA0
+ StandardA1 VirtualMachineSizeTypes = original.StandardA1
+ StandardA10 VirtualMachineSizeTypes = original.StandardA10
+ StandardA11 VirtualMachineSizeTypes = original.StandardA11
+ StandardA1V2 VirtualMachineSizeTypes = original.StandardA1V2
+ StandardA2 VirtualMachineSizeTypes = original.StandardA2
+ StandardA2mV2 VirtualMachineSizeTypes = original.StandardA2mV2
+ StandardA2V2 VirtualMachineSizeTypes = original.StandardA2V2
+ StandardA3 VirtualMachineSizeTypes = original.StandardA3
+ StandardA4 VirtualMachineSizeTypes = original.StandardA4
+ StandardA4mV2 VirtualMachineSizeTypes = original.StandardA4mV2
+ StandardA4V2 VirtualMachineSizeTypes = original.StandardA4V2
+ StandardA5 VirtualMachineSizeTypes = original.StandardA5
+ StandardA6 VirtualMachineSizeTypes = original.StandardA6
+ StandardA7 VirtualMachineSizeTypes = original.StandardA7
+ StandardA8 VirtualMachineSizeTypes = original.StandardA8
+ StandardA8mV2 VirtualMachineSizeTypes = original.StandardA8mV2
+ StandardA8V2 VirtualMachineSizeTypes = original.StandardA8V2
+ StandardA9 VirtualMachineSizeTypes = original.StandardA9
+ StandardB1ms VirtualMachineSizeTypes = original.StandardB1ms
+ StandardB1s VirtualMachineSizeTypes = original.StandardB1s
+ StandardB2ms VirtualMachineSizeTypes = original.StandardB2ms
+ StandardB2s VirtualMachineSizeTypes = original.StandardB2s
+ StandardB4ms VirtualMachineSizeTypes = original.StandardB4ms
+ StandardB8ms VirtualMachineSizeTypes = original.StandardB8ms
+ StandardD1 VirtualMachineSizeTypes = original.StandardD1
+ StandardD11 VirtualMachineSizeTypes = original.StandardD11
+ StandardD11V2 VirtualMachineSizeTypes = original.StandardD11V2
+ StandardD12 VirtualMachineSizeTypes = original.StandardD12
+ StandardD12V2 VirtualMachineSizeTypes = original.StandardD12V2
+ StandardD13 VirtualMachineSizeTypes = original.StandardD13
+ StandardD13V2 VirtualMachineSizeTypes = original.StandardD13V2
+ StandardD14 VirtualMachineSizeTypes = original.StandardD14
+ StandardD14V2 VirtualMachineSizeTypes = original.StandardD14V2
+ StandardD15V2 VirtualMachineSizeTypes = original.StandardD15V2
+ StandardD16sV3 VirtualMachineSizeTypes = original.StandardD16sV3
+ StandardD16V3 VirtualMachineSizeTypes = original.StandardD16V3
+ StandardD1V2 VirtualMachineSizeTypes = original.StandardD1V2
+ StandardD2 VirtualMachineSizeTypes = original.StandardD2
+ StandardD2sV3 VirtualMachineSizeTypes = original.StandardD2sV3
+ StandardD2V2 VirtualMachineSizeTypes = original.StandardD2V2
+ StandardD2V3 VirtualMachineSizeTypes = original.StandardD2V3
+ StandardD3 VirtualMachineSizeTypes = original.StandardD3
+ StandardD32sV3 VirtualMachineSizeTypes = original.StandardD32sV3
+ StandardD32V3 VirtualMachineSizeTypes = original.StandardD32V3
+ StandardD3V2 VirtualMachineSizeTypes = original.StandardD3V2
+ StandardD4 VirtualMachineSizeTypes = original.StandardD4
+ StandardD4sV3 VirtualMachineSizeTypes = original.StandardD4sV3
+ StandardD4V2 VirtualMachineSizeTypes = original.StandardD4V2
+ StandardD4V3 VirtualMachineSizeTypes = original.StandardD4V3
+ StandardD5V2 VirtualMachineSizeTypes = original.StandardD5V2
+ StandardD64sV3 VirtualMachineSizeTypes = original.StandardD64sV3
+ StandardD64V3 VirtualMachineSizeTypes = original.StandardD64V3
+ StandardD8sV3 VirtualMachineSizeTypes = original.StandardD8sV3
+ StandardD8V3 VirtualMachineSizeTypes = original.StandardD8V3
+ StandardDS1 VirtualMachineSizeTypes = original.StandardDS1
+ StandardDS11 VirtualMachineSizeTypes = original.StandardDS11
+ StandardDS11V2 VirtualMachineSizeTypes = original.StandardDS11V2
+ StandardDS12 VirtualMachineSizeTypes = original.StandardDS12
+ StandardDS12V2 VirtualMachineSizeTypes = original.StandardDS12V2
+ StandardDS13 VirtualMachineSizeTypes = original.StandardDS13
+ StandardDS132V2 VirtualMachineSizeTypes = original.StandardDS132V2
+ StandardDS134V2 VirtualMachineSizeTypes = original.StandardDS134V2
+ StandardDS13V2 VirtualMachineSizeTypes = original.StandardDS13V2
+ StandardDS14 VirtualMachineSizeTypes = original.StandardDS14
+ StandardDS144V2 VirtualMachineSizeTypes = original.StandardDS144V2
+ StandardDS148V2 VirtualMachineSizeTypes = original.StandardDS148V2
+ StandardDS14V2 VirtualMachineSizeTypes = original.StandardDS14V2
+ StandardDS15V2 VirtualMachineSizeTypes = original.StandardDS15V2
+ StandardDS1V2 VirtualMachineSizeTypes = original.StandardDS1V2
+ StandardDS2 VirtualMachineSizeTypes = original.StandardDS2
+ StandardDS2V2 VirtualMachineSizeTypes = original.StandardDS2V2
+ StandardDS3 VirtualMachineSizeTypes = original.StandardDS3
+ StandardDS3V2 VirtualMachineSizeTypes = original.StandardDS3V2
+ StandardDS4 VirtualMachineSizeTypes = original.StandardDS4
+ StandardDS4V2 VirtualMachineSizeTypes = original.StandardDS4V2
+ StandardDS5V2 VirtualMachineSizeTypes = original.StandardDS5V2
+ StandardE16sV3 VirtualMachineSizeTypes = original.StandardE16sV3
+ StandardE16V3 VirtualMachineSizeTypes = original.StandardE16V3
+ StandardE2sV3 VirtualMachineSizeTypes = original.StandardE2sV3
+ StandardE2V3 VirtualMachineSizeTypes = original.StandardE2V3
+ StandardE3216V3 VirtualMachineSizeTypes = original.StandardE3216V3
+ StandardE328sV3 VirtualMachineSizeTypes = original.StandardE328sV3
+ StandardE32sV3 VirtualMachineSizeTypes = original.StandardE32sV3
+ StandardE32V3 VirtualMachineSizeTypes = original.StandardE32V3
+ StandardE4sV3 VirtualMachineSizeTypes = original.StandardE4sV3
+ StandardE4V3 VirtualMachineSizeTypes = original.StandardE4V3
+ StandardE6416sV3 VirtualMachineSizeTypes = original.StandardE6416sV3
+ StandardE6432sV3 VirtualMachineSizeTypes = original.StandardE6432sV3
+ StandardE64sV3 VirtualMachineSizeTypes = original.StandardE64sV3
+ StandardE64V3 VirtualMachineSizeTypes = original.StandardE64V3
+ StandardE8sV3 VirtualMachineSizeTypes = original.StandardE8sV3
+ StandardE8V3 VirtualMachineSizeTypes = original.StandardE8V3
+ StandardF1 VirtualMachineSizeTypes = original.StandardF1
+ StandardF16 VirtualMachineSizeTypes = original.StandardF16
+ StandardF16s VirtualMachineSizeTypes = original.StandardF16s
+ StandardF16sV2 VirtualMachineSizeTypes = original.StandardF16sV2
+ StandardF1s VirtualMachineSizeTypes = original.StandardF1s
+ StandardF2 VirtualMachineSizeTypes = original.StandardF2
+ StandardF2s VirtualMachineSizeTypes = original.StandardF2s
+ StandardF2sV2 VirtualMachineSizeTypes = original.StandardF2sV2
+ StandardF32sV2 VirtualMachineSizeTypes = original.StandardF32sV2
+ StandardF4 VirtualMachineSizeTypes = original.StandardF4
+ StandardF4s VirtualMachineSizeTypes = original.StandardF4s
+ StandardF4sV2 VirtualMachineSizeTypes = original.StandardF4sV2
+ StandardF64sV2 VirtualMachineSizeTypes = original.StandardF64sV2
+ StandardF72sV2 VirtualMachineSizeTypes = original.StandardF72sV2
+ StandardF8 VirtualMachineSizeTypes = original.StandardF8
+ StandardF8s VirtualMachineSizeTypes = original.StandardF8s
+ StandardF8sV2 VirtualMachineSizeTypes = original.StandardF8sV2
+ StandardG1 VirtualMachineSizeTypes = original.StandardG1
+ StandardG2 VirtualMachineSizeTypes = original.StandardG2
+ StandardG3 VirtualMachineSizeTypes = original.StandardG3
+ StandardG4 VirtualMachineSizeTypes = original.StandardG4
+ StandardG5 VirtualMachineSizeTypes = original.StandardG5
+ StandardGS1 VirtualMachineSizeTypes = original.StandardGS1
+ StandardGS2 VirtualMachineSizeTypes = original.StandardGS2
+ StandardGS3 VirtualMachineSizeTypes = original.StandardGS3
+ StandardGS4 VirtualMachineSizeTypes = original.StandardGS4
+ StandardGS44 VirtualMachineSizeTypes = original.StandardGS44
+ StandardGS48 VirtualMachineSizeTypes = original.StandardGS48
+ StandardGS5 VirtualMachineSizeTypes = original.StandardGS5
+ StandardGS516 VirtualMachineSizeTypes = original.StandardGS516
+ StandardGS58 VirtualMachineSizeTypes = original.StandardGS58
+ StandardH16 VirtualMachineSizeTypes = original.StandardH16
+ StandardH16m VirtualMachineSizeTypes = original.StandardH16m
+ StandardH16mr VirtualMachineSizeTypes = original.StandardH16mr
+ StandardH16r VirtualMachineSizeTypes = original.StandardH16r
+ StandardH8 VirtualMachineSizeTypes = original.StandardH8
+ StandardH8m VirtualMachineSizeTypes = original.StandardH8m
+ StandardL16s VirtualMachineSizeTypes = original.StandardL16s
+ StandardL32s VirtualMachineSizeTypes = original.StandardL32s
+ StandardL4s VirtualMachineSizeTypes = original.StandardL4s
+ StandardL8s VirtualMachineSizeTypes = original.StandardL8s
+ StandardM12832ms VirtualMachineSizeTypes = original.StandardM12832ms
+ StandardM12864ms VirtualMachineSizeTypes = original.StandardM12864ms
+ StandardM128ms VirtualMachineSizeTypes = original.StandardM128ms
+ StandardM128s VirtualMachineSizeTypes = original.StandardM128s
+ StandardM6416ms VirtualMachineSizeTypes = original.StandardM6416ms
+ StandardM6432ms VirtualMachineSizeTypes = original.StandardM6432ms
+ StandardM64ms VirtualMachineSizeTypes = original.StandardM64ms
+ StandardM64s VirtualMachineSizeTypes = original.StandardM64s
+ StandardNC12 VirtualMachineSizeTypes = original.StandardNC12
+ StandardNC12sV2 VirtualMachineSizeTypes = original.StandardNC12sV2
+ StandardNC12sV3 VirtualMachineSizeTypes = original.StandardNC12sV3
+ StandardNC24 VirtualMachineSizeTypes = original.StandardNC24
+ StandardNC24r VirtualMachineSizeTypes = original.StandardNC24r
+ StandardNC24rsV2 VirtualMachineSizeTypes = original.StandardNC24rsV2
+ StandardNC24rsV3 VirtualMachineSizeTypes = original.StandardNC24rsV3
+ StandardNC24sV2 VirtualMachineSizeTypes = original.StandardNC24sV2
+ StandardNC24sV3 VirtualMachineSizeTypes = original.StandardNC24sV3
+ StandardNC6 VirtualMachineSizeTypes = original.StandardNC6
+ StandardNC6sV2 VirtualMachineSizeTypes = original.StandardNC6sV2
+ StandardNC6sV3 VirtualMachineSizeTypes = original.StandardNC6sV3
+ StandardND12s VirtualMachineSizeTypes = original.StandardND12s
+ StandardND24rs VirtualMachineSizeTypes = original.StandardND24rs
+ StandardND24s VirtualMachineSizeTypes = original.StandardND24s
+ StandardND6s VirtualMachineSizeTypes = original.StandardND6s
+ StandardNV12 VirtualMachineSizeTypes = original.StandardNV12
+ StandardNV24 VirtualMachineSizeTypes = original.StandardNV24
+ StandardNV6 VirtualMachineSizeTypes = original.StandardNV6
+)
+
+type APIEntityReference = original.APIEntityReference
+type APIError = original.APIError
+type APIErrorBase = original.APIErrorBase
+type AccessURI = original.AccessURI
+type AccessURIOutput = original.AccessURIOutput
+type AccessURIRaw = original.AccessURIRaw
+type AdditionalUnattendContent = original.AdditionalUnattendContent
+type AutoOSUpgradePolicy = original.AutoOSUpgradePolicy
+type AvailabilitySet = original.AvailabilitySet
+type AvailabilitySetListResult = original.AvailabilitySetListResult
+type AvailabilitySetListResultIterator = original.AvailabilitySetListResultIterator
+type AvailabilitySetListResultPage = original.AvailabilitySetListResultPage
+type AvailabilitySetProperties = original.AvailabilitySetProperties
+type AvailabilitySetUpdate = original.AvailabilitySetUpdate
+type AvailabilitySetsClient = original.AvailabilitySetsClient
+type BaseClient = original.BaseClient
+type BootDiagnostics = original.BootDiagnostics
+type BootDiagnosticsInstanceView = original.BootDiagnosticsInstanceView
+type CreationData = original.CreationData
+type DataDisk = original.DataDisk
+type DataDiskImage = original.DataDiskImage
+type DiagnosticsProfile = original.DiagnosticsProfile
+type Disk = original.Disk
+type DiskEncryptionSettings = original.DiskEncryptionSettings
+type DiskInstanceView = original.DiskInstanceView
+type DiskList = original.DiskList
+type DiskListIterator = original.DiskListIterator
+type DiskListPage = original.DiskListPage
+type DiskProperties = original.DiskProperties
+type DiskSku = original.DiskSku
+type DiskUpdate = original.DiskUpdate
+type DiskUpdateProperties = original.DiskUpdateProperties
+type DisksClient = original.DisksClient
+type DisksCreateOrUpdateFuture = original.DisksCreateOrUpdateFuture
+type DisksDeleteFuture = original.DisksDeleteFuture
+type DisksGrantAccessFuture = original.DisksGrantAccessFuture
+type DisksRevokeAccessFuture = original.DisksRevokeAccessFuture
+type DisksUpdateFuture = original.DisksUpdateFuture
+type EncryptionSettings = original.EncryptionSettings
+type GrantAccessData = original.GrantAccessData
+type HardwareProfile = original.HardwareProfile
+type Image = original.Image
+type ImageDataDisk = original.ImageDataDisk
+type ImageDiskReference = original.ImageDiskReference
+type ImageListResult = original.ImageListResult
+type ImageListResultIterator = original.ImageListResultIterator
+type ImageListResultPage = original.ImageListResultPage
+type ImageOSDisk = original.ImageOSDisk
+type ImageProperties = original.ImageProperties
+type ImageReference = original.ImageReference
+type ImageStorageProfile = original.ImageStorageProfile
+type ImageUpdate = original.ImageUpdate
+type ImagesClient = original.ImagesClient
+type ImagesCreateOrUpdateFuture = original.ImagesCreateOrUpdateFuture
+type ImagesDeleteFuture = original.ImagesDeleteFuture
+type ImagesUpdateFuture = original.ImagesUpdateFuture
+type InnerError = original.InnerError
+type InstanceViewStatus = original.InstanceViewStatus
+type KeyVaultAndKeyReference = original.KeyVaultAndKeyReference
+type KeyVaultAndSecretReference = original.KeyVaultAndSecretReference
+type KeyVaultKeyReference = original.KeyVaultKeyReference
+type KeyVaultSecretReference = original.KeyVaultSecretReference
+type LinuxConfiguration = original.LinuxConfiguration
+type ListUsagesResult = original.ListUsagesResult
+type ListUsagesResultIterator = original.ListUsagesResultIterator
+type ListUsagesResultPage = original.ListUsagesResultPage
+type ListVirtualMachineExtensionImage = original.ListVirtualMachineExtensionImage
+type ListVirtualMachineImageResource = original.ListVirtualMachineImageResource
+type LogAnalyticsClient = original.LogAnalyticsClient
+type LogAnalyticsExportRequestRateByIntervalFuture = original.LogAnalyticsExportRequestRateByIntervalFuture
+type LogAnalyticsExportThrottledRequestsFuture = original.LogAnalyticsExportThrottledRequestsFuture
+type LogAnalyticsInputBase = original.LogAnalyticsInputBase
+type LogAnalyticsOperationResult = original.LogAnalyticsOperationResult
+type LogAnalyticsOutput = original.LogAnalyticsOutput
+type LongRunningOperationProperties = original.LongRunningOperationProperties
+type MaintenanceRedeployStatus = original.MaintenanceRedeployStatus
+type ManagedDiskParameters = original.ManagedDiskParameters
+type NetworkInterfaceReference = original.NetworkInterfaceReference
+type NetworkInterfaceReferenceProperties = original.NetworkInterfaceReferenceProperties
+type NetworkProfile = original.NetworkProfile
+type OSDisk = original.OSDisk
+type OSDiskImage = original.OSDiskImage
+type OSProfile = original.OSProfile
+type OperationListResult = original.OperationListResult
+type OperationStatusResponse = original.OperationStatusResponse
+type OperationValue = original.OperationValue
+type OperationValueDisplay = original.OperationValueDisplay
+type OperationsClient = original.OperationsClient
+type Plan = original.Plan
+type PurchasePlan = original.PurchasePlan
+type RecoveryWalkResponse = original.RecoveryWalkResponse
+type RequestRateByIntervalInput = original.RequestRateByIntervalInput
+type Resource = original.Resource
+type ResourceSku = original.ResourceSku
+type ResourceSkuCapabilities = original.ResourceSkuCapabilities
+type ResourceSkuCapacity = original.ResourceSkuCapacity
+type ResourceSkuCosts = original.ResourceSkuCosts
+type ResourceSkuLocationInfo = original.ResourceSkuLocationInfo
+type ResourceSkuRestrictionInfo = original.ResourceSkuRestrictionInfo
+type ResourceSkuRestrictions = original.ResourceSkuRestrictions
+type ResourceSkusClient = original.ResourceSkusClient
+type ResourceSkusResult = original.ResourceSkusResult
+type ResourceSkusResultIterator = original.ResourceSkusResultIterator
+type ResourceSkusResultPage = original.ResourceSkusResultPage
+type ResourceUpdate = original.ResourceUpdate
+type RollbackStatusInfo = original.RollbackStatusInfo
+type RollingUpgradePolicy = original.RollingUpgradePolicy
+type RollingUpgradeProgressInfo = original.RollingUpgradeProgressInfo
+type RollingUpgradeRunningStatus = original.RollingUpgradeRunningStatus
+type RollingUpgradeStatusInfo = original.RollingUpgradeStatusInfo
+type RollingUpgradeStatusInfoProperties = original.RollingUpgradeStatusInfoProperties
+type RunCommandDocument = original.RunCommandDocument
+type RunCommandDocumentBase = original.RunCommandDocumentBase
+type RunCommandInput = original.RunCommandInput
+type RunCommandInputParameter = original.RunCommandInputParameter
+type RunCommandListResult = original.RunCommandListResult
+type RunCommandListResultIterator = original.RunCommandListResultIterator
+type RunCommandListResultPage = original.RunCommandListResultPage
+type RunCommandParameterDefinition = original.RunCommandParameterDefinition
+type RunCommandResult = original.RunCommandResult
+type RunCommandResultProperties = original.RunCommandResultProperties
+type SSHConfiguration = original.SSHConfiguration
+type SSHPublicKey = original.SSHPublicKey
+type Sku = original.Sku
+type Snapshot = original.Snapshot
+type SnapshotList = original.SnapshotList
+type SnapshotListIterator = original.SnapshotListIterator
+type SnapshotListPage = original.SnapshotListPage
+type SnapshotUpdate = original.SnapshotUpdate
+type SnapshotsClient = original.SnapshotsClient
+type SnapshotsCreateOrUpdateFuture = original.SnapshotsCreateOrUpdateFuture
+type SnapshotsDeleteFuture = original.SnapshotsDeleteFuture
+type SnapshotsGrantAccessFuture = original.SnapshotsGrantAccessFuture
+type SnapshotsRevokeAccessFuture = original.SnapshotsRevokeAccessFuture
+type SnapshotsUpdateFuture = original.SnapshotsUpdateFuture
+type SourceVault = original.SourceVault
+type StorageProfile = original.StorageProfile
+type SubResource = original.SubResource
+type SubResourceReadOnly = original.SubResourceReadOnly
+type ThrottledRequestsInput = original.ThrottledRequestsInput
+type UpdateResource = original.UpdateResource
+type UpgradeOperationHistoricalStatusInfo = original.UpgradeOperationHistoricalStatusInfo
+type UpgradeOperationHistoricalStatusInfoProperties = original.UpgradeOperationHistoricalStatusInfoProperties
+type UpgradeOperationHistoryStatus = original.UpgradeOperationHistoryStatus
+type UpgradePolicy = original.UpgradePolicy
+type Usage = original.Usage
+type UsageClient = original.UsageClient
+type UsageName = original.UsageName
+type VaultCertificate = original.VaultCertificate
+type VaultSecretGroup = original.VaultSecretGroup
+type VirtualHardDisk = original.VirtualHardDisk
+type VirtualMachine = original.VirtualMachine
+type VirtualMachineAgentInstanceView = original.VirtualMachineAgentInstanceView
+type VirtualMachineCaptureParameters = original.VirtualMachineCaptureParameters
+type VirtualMachineCaptureResult = original.VirtualMachineCaptureResult
+type VirtualMachineCaptureResultProperties = original.VirtualMachineCaptureResultProperties
+type VirtualMachineExtension = original.VirtualMachineExtension
+type VirtualMachineExtensionHandlerInstanceView = original.VirtualMachineExtensionHandlerInstanceView
+type VirtualMachineExtensionImage = original.VirtualMachineExtensionImage
+type VirtualMachineExtensionImageProperties = original.VirtualMachineExtensionImageProperties
+type VirtualMachineExtensionImagesClient = original.VirtualMachineExtensionImagesClient
+type VirtualMachineExtensionInstanceView = original.VirtualMachineExtensionInstanceView
+type VirtualMachineExtensionProperties = original.VirtualMachineExtensionProperties
+type VirtualMachineExtensionUpdate = original.VirtualMachineExtensionUpdate
+type VirtualMachineExtensionUpdateProperties = original.VirtualMachineExtensionUpdateProperties
+type VirtualMachineExtensionsClient = original.VirtualMachineExtensionsClient
+type VirtualMachineExtensionsCreateOrUpdateFuture = original.VirtualMachineExtensionsCreateOrUpdateFuture
+type VirtualMachineExtensionsDeleteFuture = original.VirtualMachineExtensionsDeleteFuture
+type VirtualMachineExtensionsListResult = original.VirtualMachineExtensionsListResult
+type VirtualMachineExtensionsUpdateFuture = original.VirtualMachineExtensionsUpdateFuture
+type VirtualMachineHealthStatus = original.VirtualMachineHealthStatus
+type VirtualMachineIdentity = original.VirtualMachineIdentity
+type VirtualMachineImage = original.VirtualMachineImage
+type VirtualMachineImageProperties = original.VirtualMachineImageProperties
+type VirtualMachineImageResource = original.VirtualMachineImageResource
+type VirtualMachineImagesClient = original.VirtualMachineImagesClient
+type VirtualMachineInstanceView = original.VirtualMachineInstanceView
+type VirtualMachineListResult = original.VirtualMachineListResult
+type VirtualMachineListResultIterator = original.VirtualMachineListResultIterator
+type VirtualMachineListResultPage = original.VirtualMachineListResultPage
+type VirtualMachineProperties = original.VirtualMachineProperties
+type VirtualMachineRunCommandsClient = original.VirtualMachineRunCommandsClient
+type VirtualMachineScaleSet = original.VirtualMachineScaleSet
+type VirtualMachineScaleSetDataDisk = original.VirtualMachineScaleSetDataDisk
+type VirtualMachineScaleSetExtension = original.VirtualMachineScaleSetExtension
+type VirtualMachineScaleSetExtensionListResult = original.VirtualMachineScaleSetExtensionListResult
+type VirtualMachineScaleSetExtensionListResultIterator = original.VirtualMachineScaleSetExtensionListResultIterator
+type VirtualMachineScaleSetExtensionListResultPage = original.VirtualMachineScaleSetExtensionListResultPage
+type VirtualMachineScaleSetExtensionProfile = original.VirtualMachineScaleSetExtensionProfile
+type VirtualMachineScaleSetExtensionProperties = original.VirtualMachineScaleSetExtensionProperties
+type VirtualMachineScaleSetExtensionsClient = original.VirtualMachineScaleSetExtensionsClient
+type VirtualMachineScaleSetExtensionsCreateOrUpdateFuture = original.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture
+type VirtualMachineScaleSetExtensionsDeleteFuture = original.VirtualMachineScaleSetExtensionsDeleteFuture
+type VirtualMachineScaleSetIPConfiguration = original.VirtualMachineScaleSetIPConfiguration
+type VirtualMachineScaleSetIPConfigurationProperties = original.VirtualMachineScaleSetIPConfigurationProperties
+type VirtualMachineScaleSetIdentity = original.VirtualMachineScaleSetIdentity
+type VirtualMachineScaleSetInstanceView = original.VirtualMachineScaleSetInstanceView
+type VirtualMachineScaleSetInstanceViewStatusesSummary = original.VirtualMachineScaleSetInstanceViewStatusesSummary
+type VirtualMachineScaleSetListOSUpgradeHistory = original.VirtualMachineScaleSetListOSUpgradeHistory
+type VirtualMachineScaleSetListOSUpgradeHistoryIterator = original.VirtualMachineScaleSetListOSUpgradeHistoryIterator
+type VirtualMachineScaleSetListOSUpgradeHistoryPage = original.VirtualMachineScaleSetListOSUpgradeHistoryPage
+type VirtualMachineScaleSetListResult = original.VirtualMachineScaleSetListResult
+type VirtualMachineScaleSetListResultIterator = original.VirtualMachineScaleSetListResultIterator
+type VirtualMachineScaleSetListResultPage = original.VirtualMachineScaleSetListResultPage
+type VirtualMachineScaleSetListSkusResult = original.VirtualMachineScaleSetListSkusResult
+type VirtualMachineScaleSetListSkusResultIterator = original.VirtualMachineScaleSetListSkusResultIterator
+type VirtualMachineScaleSetListSkusResultPage = original.VirtualMachineScaleSetListSkusResultPage
+type VirtualMachineScaleSetListWithLinkResult = original.VirtualMachineScaleSetListWithLinkResult
+type VirtualMachineScaleSetListWithLinkResultIterator = original.VirtualMachineScaleSetListWithLinkResultIterator
+type VirtualMachineScaleSetListWithLinkResultPage = original.VirtualMachineScaleSetListWithLinkResultPage
+type VirtualMachineScaleSetManagedDiskParameters = original.VirtualMachineScaleSetManagedDiskParameters
+type VirtualMachineScaleSetNetworkConfiguration = original.VirtualMachineScaleSetNetworkConfiguration
+type VirtualMachineScaleSetNetworkConfigurationDNSSettings = original.VirtualMachineScaleSetNetworkConfigurationDNSSettings
+type VirtualMachineScaleSetNetworkConfigurationProperties = original.VirtualMachineScaleSetNetworkConfigurationProperties
+type VirtualMachineScaleSetNetworkProfile = original.VirtualMachineScaleSetNetworkProfile
+type VirtualMachineScaleSetOSDisk = original.VirtualMachineScaleSetOSDisk
+type VirtualMachineScaleSetOSProfile = original.VirtualMachineScaleSetOSProfile
+type VirtualMachineScaleSetProperties = original.VirtualMachineScaleSetProperties
+type VirtualMachineScaleSetPublicIPAddressConfiguration = original.VirtualMachineScaleSetPublicIPAddressConfiguration
+type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings = original.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings
+type VirtualMachineScaleSetPublicIPAddressConfigurationProperties = original.VirtualMachineScaleSetPublicIPAddressConfigurationProperties
+type VirtualMachineScaleSetRollingUpgradesCancelFuture = original.VirtualMachineScaleSetRollingUpgradesCancelFuture
+type VirtualMachineScaleSetRollingUpgradesClient = original.VirtualMachineScaleSetRollingUpgradesClient
+type VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture = original.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture
+type VirtualMachineScaleSetSku = original.VirtualMachineScaleSetSku
+type VirtualMachineScaleSetSkuCapacity = original.VirtualMachineScaleSetSkuCapacity
+type VirtualMachineScaleSetStorageProfile = original.VirtualMachineScaleSetStorageProfile
+type VirtualMachineScaleSetUpdate = original.VirtualMachineScaleSetUpdate
+type VirtualMachineScaleSetUpdateIPConfiguration = original.VirtualMachineScaleSetUpdateIPConfiguration
+type VirtualMachineScaleSetUpdateIPConfigurationProperties = original.VirtualMachineScaleSetUpdateIPConfigurationProperties
+type VirtualMachineScaleSetUpdateNetworkConfiguration = original.VirtualMachineScaleSetUpdateNetworkConfiguration
+type VirtualMachineScaleSetUpdateNetworkConfigurationProperties = original.VirtualMachineScaleSetUpdateNetworkConfigurationProperties
+type VirtualMachineScaleSetUpdateNetworkProfile = original.VirtualMachineScaleSetUpdateNetworkProfile
+type VirtualMachineScaleSetUpdateOSDisk = original.VirtualMachineScaleSetUpdateOSDisk
+type VirtualMachineScaleSetUpdateOSProfile = original.VirtualMachineScaleSetUpdateOSProfile
+type VirtualMachineScaleSetUpdateProperties = original.VirtualMachineScaleSetUpdateProperties
+type VirtualMachineScaleSetUpdatePublicIPAddressConfiguration = original.VirtualMachineScaleSetUpdatePublicIPAddressConfiguration
+type VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties = original.VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties
+type VirtualMachineScaleSetUpdateStorageProfile = original.VirtualMachineScaleSetUpdateStorageProfile
+type VirtualMachineScaleSetUpdateVMProfile = original.VirtualMachineScaleSetUpdateVMProfile
+type VirtualMachineScaleSetVM = original.VirtualMachineScaleSetVM
+type VirtualMachineScaleSetVMExtensionsSummary = original.VirtualMachineScaleSetVMExtensionsSummary
+type VirtualMachineScaleSetVMInstanceIDs = original.VirtualMachineScaleSetVMInstanceIDs
+type VirtualMachineScaleSetVMInstanceRequiredIDs = original.VirtualMachineScaleSetVMInstanceRequiredIDs
+type VirtualMachineScaleSetVMInstanceView = original.VirtualMachineScaleSetVMInstanceView
+type VirtualMachineScaleSetVMListResult = original.VirtualMachineScaleSetVMListResult
+type VirtualMachineScaleSetVMListResultIterator = original.VirtualMachineScaleSetVMListResultIterator
+type VirtualMachineScaleSetVMListResultPage = original.VirtualMachineScaleSetVMListResultPage
+type VirtualMachineScaleSetVMProfile = original.VirtualMachineScaleSetVMProfile
+type VirtualMachineScaleSetVMProperties = original.VirtualMachineScaleSetVMProperties
+type VirtualMachineScaleSetVMsClient = original.VirtualMachineScaleSetVMsClient
+type VirtualMachineScaleSetVMsDeallocateFuture = original.VirtualMachineScaleSetVMsDeallocateFuture
+type VirtualMachineScaleSetVMsDeleteFuture = original.VirtualMachineScaleSetVMsDeleteFuture
+type VirtualMachineScaleSetVMsPerformMaintenanceFuture = original.VirtualMachineScaleSetVMsPerformMaintenanceFuture
+type VirtualMachineScaleSetVMsPowerOffFuture = original.VirtualMachineScaleSetVMsPowerOffFuture
+type VirtualMachineScaleSetVMsRedeployFuture = original.VirtualMachineScaleSetVMsRedeployFuture
+type VirtualMachineScaleSetVMsReimageAllFuture = original.VirtualMachineScaleSetVMsReimageAllFuture
+type VirtualMachineScaleSetVMsReimageFuture = original.VirtualMachineScaleSetVMsReimageFuture
+type VirtualMachineScaleSetVMsRestartFuture = original.VirtualMachineScaleSetVMsRestartFuture
+type VirtualMachineScaleSetVMsStartFuture = original.VirtualMachineScaleSetVMsStartFuture
+type VirtualMachineScaleSetVMsUpdateFuture = original.VirtualMachineScaleSetVMsUpdateFuture
+type VirtualMachineScaleSetsClient = original.VirtualMachineScaleSetsClient
+type VirtualMachineScaleSetsCreateOrUpdateFuture = original.VirtualMachineScaleSetsCreateOrUpdateFuture
+type VirtualMachineScaleSetsDeallocateFuture = original.VirtualMachineScaleSetsDeallocateFuture
+type VirtualMachineScaleSetsDeleteFuture = original.VirtualMachineScaleSetsDeleteFuture
+type VirtualMachineScaleSetsDeleteInstancesFuture = original.VirtualMachineScaleSetsDeleteInstancesFuture
+type VirtualMachineScaleSetsPerformMaintenanceFuture = original.VirtualMachineScaleSetsPerformMaintenanceFuture
+type VirtualMachineScaleSetsPowerOffFuture = original.VirtualMachineScaleSetsPowerOffFuture
+type VirtualMachineScaleSetsRedeployFuture = original.VirtualMachineScaleSetsRedeployFuture
+type VirtualMachineScaleSetsReimageAllFuture = original.VirtualMachineScaleSetsReimageAllFuture
+type VirtualMachineScaleSetsReimageFuture = original.VirtualMachineScaleSetsReimageFuture
+type VirtualMachineScaleSetsRestartFuture = original.VirtualMachineScaleSetsRestartFuture
+type VirtualMachineScaleSetsStartFuture = original.VirtualMachineScaleSetsStartFuture
+type VirtualMachineScaleSetsUpdateFuture = original.VirtualMachineScaleSetsUpdateFuture
+type VirtualMachineScaleSetsUpdateInstancesFuture = original.VirtualMachineScaleSetsUpdateInstancesFuture
+type VirtualMachineSize = original.VirtualMachineSize
+type VirtualMachineSizeListResult = original.VirtualMachineSizeListResult
+type VirtualMachineSizesClient = original.VirtualMachineSizesClient
+type VirtualMachineStatusCodeCount = original.VirtualMachineStatusCodeCount
+type VirtualMachineUpdate = original.VirtualMachineUpdate
+type VirtualMachinesCaptureFuture = original.VirtualMachinesCaptureFuture
+type VirtualMachinesClient = original.VirtualMachinesClient
+type VirtualMachinesConvertToManagedDisksFuture = original.VirtualMachinesConvertToManagedDisksFuture
+type VirtualMachinesCreateOrUpdateFuture = original.VirtualMachinesCreateOrUpdateFuture
+type VirtualMachinesDeallocateFuture = original.VirtualMachinesDeallocateFuture
+type VirtualMachinesDeleteFuture = original.VirtualMachinesDeleteFuture
+type VirtualMachinesPerformMaintenanceFuture = original.VirtualMachinesPerformMaintenanceFuture
+type VirtualMachinesPowerOffFuture = original.VirtualMachinesPowerOffFuture
+type VirtualMachinesRedeployFuture = original.VirtualMachinesRedeployFuture
+type VirtualMachinesRestartFuture = original.VirtualMachinesRestartFuture
+type VirtualMachinesRunCommandFuture = original.VirtualMachinesRunCommandFuture
+type VirtualMachinesStartFuture = original.VirtualMachinesStartFuture
+type VirtualMachinesUpdateFuture = original.VirtualMachinesUpdateFuture
+type WinRMConfiguration = original.WinRMConfiguration
+type WinRMListener = original.WinRMListener
+type WindowsConfiguration = original.WindowsConfiguration
+
+func New(subscriptionID string) BaseClient {
+ return original.New(subscriptionID)
+}
+func NewAvailabilitySetListResultIterator(page AvailabilitySetListResultPage) AvailabilitySetListResultIterator {
+ return original.NewAvailabilitySetListResultIterator(page)
+}
+func NewAvailabilitySetListResultPage(cur AvailabilitySetListResult, getNextPage func(context.Context, AvailabilitySetListResult) (AvailabilitySetListResult, error)) AvailabilitySetListResultPage {
+ return original.NewAvailabilitySetListResultPage(cur, getNextPage)
+}
+func NewAvailabilitySetsClient(subscriptionID string) AvailabilitySetsClient {
+ return original.NewAvailabilitySetsClient(subscriptionID)
+}
+func NewAvailabilitySetsClientWithBaseURI(baseURI string, subscriptionID string) AvailabilitySetsClient {
+ return original.NewAvailabilitySetsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewDiskListIterator(page DiskListPage) DiskListIterator {
+ return original.NewDiskListIterator(page)
+}
+func NewDiskListPage(cur DiskList, getNextPage func(context.Context, DiskList) (DiskList, error)) DiskListPage {
+ return original.NewDiskListPage(cur, getNextPage)
+}
+func NewDisksClient(subscriptionID string) DisksClient {
+ return original.NewDisksClient(subscriptionID)
+}
+func NewDisksClientWithBaseURI(baseURI string, subscriptionID string) DisksClient {
+ return original.NewDisksClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewImageListResultIterator(page ImageListResultPage) ImageListResultIterator {
+ return original.NewImageListResultIterator(page)
+}
+func NewImageListResultPage(cur ImageListResult, getNextPage func(context.Context, ImageListResult) (ImageListResult, error)) ImageListResultPage {
+ return original.NewImageListResultPage(cur, getNextPage)
+}
+func NewImagesClient(subscriptionID string) ImagesClient {
+ return original.NewImagesClient(subscriptionID)
+}
+func NewImagesClientWithBaseURI(baseURI string, subscriptionID string) ImagesClient {
+ return original.NewImagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewListUsagesResultIterator(page ListUsagesResultPage) ListUsagesResultIterator {
+ return original.NewListUsagesResultIterator(page)
+}
+func NewListUsagesResultPage(cur ListUsagesResult, getNextPage func(context.Context, ListUsagesResult) (ListUsagesResult, error)) ListUsagesResultPage {
+ return original.NewListUsagesResultPage(cur, getNextPage)
+}
+func NewLogAnalyticsClient(subscriptionID string) LogAnalyticsClient {
+ return original.NewLogAnalyticsClient(subscriptionID)
+}
+func NewLogAnalyticsClientWithBaseURI(baseURI string, subscriptionID string) LogAnalyticsClient {
+ return original.NewLogAnalyticsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewOperationsClient(subscriptionID string) OperationsClient {
+ return original.NewOperationsClient(subscriptionID)
+}
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+ return original.NewOperationsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewResourceSkusClient(subscriptionID string) ResourceSkusClient {
+ return original.NewResourceSkusClient(subscriptionID)
+}
+func NewResourceSkusClientWithBaseURI(baseURI string, subscriptionID string) ResourceSkusClient {
+ return original.NewResourceSkusClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewResourceSkusResultIterator(page ResourceSkusResultPage) ResourceSkusResultIterator {
+ return original.NewResourceSkusResultIterator(page)
+}
+func NewResourceSkusResultPage(cur ResourceSkusResult, getNextPage func(context.Context, ResourceSkusResult) (ResourceSkusResult, error)) ResourceSkusResultPage {
+ return original.NewResourceSkusResultPage(cur, getNextPage)
+}
+func NewRunCommandListResultIterator(page RunCommandListResultPage) RunCommandListResultIterator {
+ return original.NewRunCommandListResultIterator(page)
+}
+func NewRunCommandListResultPage(cur RunCommandListResult, getNextPage func(context.Context, RunCommandListResult) (RunCommandListResult, error)) RunCommandListResultPage {
+ return original.NewRunCommandListResultPage(cur, getNextPage)
+}
+func NewSnapshotListIterator(page SnapshotListPage) SnapshotListIterator {
+ return original.NewSnapshotListIterator(page)
+}
+func NewSnapshotListPage(cur SnapshotList, getNextPage func(context.Context, SnapshotList) (SnapshotList, error)) SnapshotListPage {
+ return original.NewSnapshotListPage(cur, getNextPage)
+}
+func NewSnapshotsClient(subscriptionID string) SnapshotsClient {
+ return original.NewSnapshotsClient(subscriptionID)
+}
+func NewSnapshotsClientWithBaseURI(baseURI string, subscriptionID string) SnapshotsClient {
+ return original.NewSnapshotsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewUsageClient(subscriptionID string) UsageClient {
+ return original.NewUsageClient(subscriptionID)
+}
+func NewUsageClientWithBaseURI(baseURI string, subscriptionID string) UsageClient {
+ return original.NewUsageClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineExtensionImagesClient(subscriptionID string) VirtualMachineExtensionImagesClient {
+ return original.NewVirtualMachineExtensionImagesClient(subscriptionID)
+}
+func NewVirtualMachineExtensionImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionImagesClient {
+ return original.NewVirtualMachineExtensionImagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineExtensionsClient(subscriptionID string) VirtualMachineExtensionsClient {
+ return original.NewVirtualMachineExtensionsClient(subscriptionID)
+}
+func NewVirtualMachineExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionsClient {
+ return original.NewVirtualMachineExtensionsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineImagesClient(subscriptionID string) VirtualMachineImagesClient {
+ return original.NewVirtualMachineImagesClient(subscriptionID)
+}
+func NewVirtualMachineImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineImagesClient {
+ return original.NewVirtualMachineImagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineListResultIterator(page VirtualMachineListResultPage) VirtualMachineListResultIterator {
+ return original.NewVirtualMachineListResultIterator(page)
+}
+func NewVirtualMachineListResultPage(cur VirtualMachineListResult, getNextPage func(context.Context, VirtualMachineListResult) (VirtualMachineListResult, error)) VirtualMachineListResultPage {
+ return original.NewVirtualMachineListResultPage(cur, getNextPage)
+}
+func NewVirtualMachineRunCommandsClient(subscriptionID string) VirtualMachineRunCommandsClient {
+ return original.NewVirtualMachineRunCommandsClient(subscriptionID)
+}
+func NewVirtualMachineRunCommandsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineRunCommandsClient {
+ return original.NewVirtualMachineRunCommandsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetExtensionListResultIterator(page VirtualMachineScaleSetExtensionListResultPage) VirtualMachineScaleSetExtensionListResultIterator {
+ return original.NewVirtualMachineScaleSetExtensionListResultIterator(page)
+}
+func NewVirtualMachineScaleSetExtensionListResultPage(cur VirtualMachineScaleSetExtensionListResult, getNextPage func(context.Context, VirtualMachineScaleSetExtensionListResult) (VirtualMachineScaleSetExtensionListResult, error)) VirtualMachineScaleSetExtensionListResultPage {
+ return original.NewVirtualMachineScaleSetExtensionListResultPage(cur, getNextPage)
+}
+func NewVirtualMachineScaleSetExtensionsClient(subscriptionID string) VirtualMachineScaleSetExtensionsClient {
+ return original.NewVirtualMachineScaleSetExtensionsClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetExtensionsClient {
+ return original.NewVirtualMachineScaleSetExtensionsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetListOSUpgradeHistoryIterator(page VirtualMachineScaleSetListOSUpgradeHistoryPage) VirtualMachineScaleSetListOSUpgradeHistoryIterator {
+ return original.NewVirtualMachineScaleSetListOSUpgradeHistoryIterator(page)
+}
+func NewVirtualMachineScaleSetListOSUpgradeHistoryPage(cur VirtualMachineScaleSetListOSUpgradeHistory, getNextPage func(context.Context, VirtualMachineScaleSetListOSUpgradeHistory) (VirtualMachineScaleSetListOSUpgradeHistory, error)) VirtualMachineScaleSetListOSUpgradeHistoryPage {
+ return original.NewVirtualMachineScaleSetListOSUpgradeHistoryPage(cur, getNextPage)
+}
+func NewVirtualMachineScaleSetListResultIterator(page VirtualMachineScaleSetListResultPage) VirtualMachineScaleSetListResultIterator {
+ return original.NewVirtualMachineScaleSetListResultIterator(page)
+}
+func NewVirtualMachineScaleSetListResultPage(cur VirtualMachineScaleSetListResult, getNextPage func(context.Context, VirtualMachineScaleSetListResult) (VirtualMachineScaleSetListResult, error)) VirtualMachineScaleSetListResultPage {
+ return original.NewVirtualMachineScaleSetListResultPage(cur, getNextPage)
+}
+func NewVirtualMachineScaleSetListSkusResultIterator(page VirtualMachineScaleSetListSkusResultPage) VirtualMachineScaleSetListSkusResultIterator {
+ return original.NewVirtualMachineScaleSetListSkusResultIterator(page)
+}
+func NewVirtualMachineScaleSetListSkusResultPage(cur VirtualMachineScaleSetListSkusResult, getNextPage func(context.Context, VirtualMachineScaleSetListSkusResult) (VirtualMachineScaleSetListSkusResult, error)) VirtualMachineScaleSetListSkusResultPage {
+ return original.NewVirtualMachineScaleSetListSkusResultPage(cur, getNextPage)
+}
+func NewVirtualMachineScaleSetListWithLinkResultIterator(page VirtualMachineScaleSetListWithLinkResultPage) VirtualMachineScaleSetListWithLinkResultIterator {
+ return original.NewVirtualMachineScaleSetListWithLinkResultIterator(page)
+}
+func NewVirtualMachineScaleSetListWithLinkResultPage(cur VirtualMachineScaleSetListWithLinkResult, getNextPage func(context.Context, VirtualMachineScaleSetListWithLinkResult) (VirtualMachineScaleSetListWithLinkResult, error)) VirtualMachineScaleSetListWithLinkResultPage {
+ return original.NewVirtualMachineScaleSetListWithLinkResultPage(cur, getNextPage)
+}
+func NewVirtualMachineScaleSetRollingUpgradesClient(subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
+ return original.NewVirtualMachineScaleSetRollingUpgradesClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
+ return original.NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetVMListResultIterator(page VirtualMachineScaleSetVMListResultPage) VirtualMachineScaleSetVMListResultIterator {
+ return original.NewVirtualMachineScaleSetVMListResultIterator(page)
+}
+func NewVirtualMachineScaleSetVMListResultPage(cur VirtualMachineScaleSetVMListResult, getNextPage func(context.Context, VirtualMachineScaleSetVMListResult) (VirtualMachineScaleSetVMListResult, error)) VirtualMachineScaleSetVMListResultPage {
+ return original.NewVirtualMachineScaleSetVMListResultPage(cur, getNextPage)
+}
+func NewVirtualMachineScaleSetVMsClient(subscriptionID string) VirtualMachineScaleSetVMsClient {
+ return original.NewVirtualMachineScaleSetVMsClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetVMsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetVMsClient {
+ return original.NewVirtualMachineScaleSetVMsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetsClient(subscriptionID string) VirtualMachineScaleSetsClient {
+ return original.NewVirtualMachineScaleSetsClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetsClient {
+ return original.NewVirtualMachineScaleSetsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineSizesClient(subscriptionID string) VirtualMachineSizesClient {
+ return original.NewVirtualMachineSizesClient(subscriptionID)
+}
+func NewVirtualMachineSizesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineSizesClient {
+ return original.NewVirtualMachineSizesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachinesClient(subscriptionID string) VirtualMachinesClient {
+ return original.NewVirtualMachinesClient(subscriptionID)
+}
+func NewVirtualMachinesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachinesClient {
+ return original.NewVirtualMachinesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+ return original.NewWithBaseURI(baseURI, subscriptionID)
+}
+func PossibleAccessLevelValues() []AccessLevel {
+ return original.PossibleAccessLevelValues()
+}
+func PossibleCachingTypesValues() []CachingTypes {
+ return original.PossibleCachingTypesValues()
+}
+func PossibleComponentNamesValues() []ComponentNames {
+ return original.PossibleComponentNamesValues()
+}
+func PossibleDiskCreateOptionTypesValues() []DiskCreateOptionTypes {
+ return original.PossibleDiskCreateOptionTypesValues()
+}
+func PossibleDiskCreateOptionValues() []DiskCreateOption {
+ return original.PossibleDiskCreateOptionValues()
+}
+func PossibleIPVersionValues() []IPVersion {
+ return original.PossibleIPVersionValues()
+}
+func PossibleInstanceViewTypesValues() []InstanceViewTypes {
+ return original.PossibleInstanceViewTypesValues()
+}
+func PossibleIntervalInMinsValues() []IntervalInMins {
+ return original.PossibleIntervalInMinsValues()
+}
+func PossibleMaintenanceOperationResultCodeTypesValues() []MaintenanceOperationResultCodeTypes {
+ return original.PossibleMaintenanceOperationResultCodeTypesValues()
+}
+func PossibleOperatingSystemStateTypesValues() []OperatingSystemStateTypes {
+ return original.PossibleOperatingSystemStateTypesValues()
+}
+func PossibleOperatingSystemTypesValues() []OperatingSystemTypes {
+ return original.PossibleOperatingSystemTypesValues()
+}
+func PossiblePassNamesValues() []PassNames {
+ return original.PossiblePassNamesValues()
+}
+func PossibleProtocolTypesValues() []ProtocolTypes {
+ return original.PossibleProtocolTypesValues()
+}
+func PossibleResourceIdentityTypeValues() []ResourceIdentityType {
+ return original.PossibleResourceIdentityTypeValues()
+}
+func PossibleResourceSkuCapacityScaleTypeValues() []ResourceSkuCapacityScaleType {
+ return original.PossibleResourceSkuCapacityScaleTypeValues()
+}
+func PossibleResourceSkuRestrictionsReasonCodeValues() []ResourceSkuRestrictionsReasonCode {
+ return original.PossibleResourceSkuRestrictionsReasonCodeValues()
+}
+func PossibleResourceSkuRestrictionsTypeValues() []ResourceSkuRestrictionsType {
+ return original.PossibleResourceSkuRestrictionsTypeValues()
+}
+func PossibleRollingUpgradeActionTypeValues() []RollingUpgradeActionType {
+ return original.PossibleRollingUpgradeActionTypeValues()
+}
+func PossibleRollingUpgradeStatusCodeValues() []RollingUpgradeStatusCode {
+ return original.PossibleRollingUpgradeStatusCodeValues()
+}
+func PossibleSettingNamesValues() []SettingNames {
+ return original.PossibleSettingNamesValues()
+}
+func PossibleStatusLevelTypesValues() []StatusLevelTypes {
+ return original.PossibleStatusLevelTypesValues()
+}
+func PossibleStorageAccountTypesValues() []StorageAccountTypes {
+ return original.PossibleStorageAccountTypesValues()
+}
+func PossibleUpgradeModeValues() []UpgradeMode {
+ return original.PossibleUpgradeModeValues()
+}
+func PossibleUpgradeOperationInvokerValues() []UpgradeOperationInvoker {
+ return original.PossibleUpgradeOperationInvokerValues()
+}
+func PossibleUpgradeStateValues() []UpgradeState {
+ return original.PossibleUpgradeStateValues()
+}
+func PossibleVirtualMachineEvictionPolicyTypesValues() []VirtualMachineEvictionPolicyTypes {
+ return original.PossibleVirtualMachineEvictionPolicyTypesValues()
+}
+func PossibleVirtualMachinePriorityTypesValues() []VirtualMachinePriorityTypes {
+ return original.PossibleVirtualMachinePriorityTypesValues()
+}
+func PossibleVirtualMachineScaleSetSkuScaleTypeValues() []VirtualMachineScaleSetSkuScaleType {
+ return original.PossibleVirtualMachineScaleSetSkuScaleTypeValues()
+}
+func PossibleVirtualMachineSizeTypesValues() []VirtualMachineSizeTypes {
+ return original.PossibleVirtualMachineSizeTypesValues()
+}
+func UserAgent() string {
+ return original.UserAgent() + " profiles/2019-03-01"
+}
+func Version() string {
+ return original.Version()
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network/models.go b/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network/models.go
new file mode 100644
index 00000000000..86fdc589429
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network/models.go
@@ -0,0 +1,1746 @@
+// +build go1.9
+
+// Copyright 2021 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This code was auto-generated by:
+// github.com/Azure/azure-sdk-for-go/tools/profileBuilder
+
+package network
+
+import (
+ "context"
+
+ original "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network"
+)
+
+const (
+ DefaultBaseURI = original.DefaultBaseURI
+)
+
+type Access = original.Access
+
+const (
+ Allow Access = original.Allow
+ Deny Access = original.Deny
+)
+
+type ApplicationGatewayBackendHealthServerHealth = original.ApplicationGatewayBackendHealthServerHealth
+
+const (
+ Down ApplicationGatewayBackendHealthServerHealth = original.Down
+ Draining ApplicationGatewayBackendHealthServerHealth = original.Draining
+ Partial ApplicationGatewayBackendHealthServerHealth = original.Partial
+ Unknown ApplicationGatewayBackendHealthServerHealth = original.Unknown
+ Up ApplicationGatewayBackendHealthServerHealth = original.Up
+)
+
+type ApplicationGatewayCookieBasedAffinity = original.ApplicationGatewayCookieBasedAffinity
+
+const (
+ Disabled ApplicationGatewayCookieBasedAffinity = original.Disabled
+ Enabled ApplicationGatewayCookieBasedAffinity = original.Enabled
+)
+
+type ApplicationGatewayFirewallMode = original.ApplicationGatewayFirewallMode
+
+const (
+ Detection ApplicationGatewayFirewallMode = original.Detection
+ Prevention ApplicationGatewayFirewallMode = original.Prevention
+)
+
+type ApplicationGatewayOperationalState = original.ApplicationGatewayOperationalState
+
+const (
+ Running ApplicationGatewayOperationalState = original.Running
+ Starting ApplicationGatewayOperationalState = original.Starting
+ Stopped ApplicationGatewayOperationalState = original.Stopped
+ Stopping ApplicationGatewayOperationalState = original.Stopping
+)
+
+type ApplicationGatewayProtocol = original.ApplicationGatewayProtocol
+
+const (
+ HTTP ApplicationGatewayProtocol = original.HTTP
+ HTTPS ApplicationGatewayProtocol = original.HTTPS
+)
+
+type ApplicationGatewayRedirectType = original.ApplicationGatewayRedirectType
+
+const (
+ Found ApplicationGatewayRedirectType = original.Found
+ Permanent ApplicationGatewayRedirectType = original.Permanent
+ SeeOther ApplicationGatewayRedirectType = original.SeeOther
+ Temporary ApplicationGatewayRedirectType = original.Temporary
+)
+
+type ApplicationGatewayRequestRoutingRuleType = original.ApplicationGatewayRequestRoutingRuleType
+
+const (
+ Basic ApplicationGatewayRequestRoutingRuleType = original.Basic
+ PathBasedRouting ApplicationGatewayRequestRoutingRuleType = original.PathBasedRouting
+)
+
+type ApplicationGatewaySkuName = original.ApplicationGatewaySkuName
+
+const (
+ StandardLarge ApplicationGatewaySkuName = original.StandardLarge
+ StandardMedium ApplicationGatewaySkuName = original.StandardMedium
+ StandardSmall ApplicationGatewaySkuName = original.StandardSmall
+ WAFLarge ApplicationGatewaySkuName = original.WAFLarge
+ WAFMedium ApplicationGatewaySkuName = original.WAFMedium
+)
+
+type ApplicationGatewaySslCipherSuite = original.ApplicationGatewaySslCipherSuite
+
+const (
+ TLSDHEDSSWITH3DESEDECBCSHA ApplicationGatewaySslCipherSuite = original.TLSDHEDSSWITH3DESEDECBCSHA
+ TLSDHEDSSWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = original.TLSDHEDSSWITHAES128CBCSHA
+ TLSDHEDSSWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = original.TLSDHEDSSWITHAES128CBCSHA256
+ TLSDHEDSSWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = original.TLSDHEDSSWITHAES256CBCSHA
+ TLSDHEDSSWITHAES256CBCSHA256 ApplicationGatewaySslCipherSuite = original.TLSDHEDSSWITHAES256CBCSHA256
+ TLSDHERSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = original.TLSDHERSAWITHAES128CBCSHA
+ TLSDHERSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = original.TLSDHERSAWITHAES128GCMSHA256
+ TLSDHERSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = original.TLSDHERSAWITHAES256CBCSHA
+ TLSDHERSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = original.TLSDHERSAWITHAES256GCMSHA384
+ TLSECDHEECDSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = original.TLSECDHEECDSAWITHAES128CBCSHA
+ TLSECDHEECDSAWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = original.TLSECDHEECDSAWITHAES128CBCSHA256
+ TLSECDHEECDSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = original.TLSECDHEECDSAWITHAES128GCMSHA256
+ TLSECDHEECDSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = original.TLSECDHEECDSAWITHAES256CBCSHA
+ TLSECDHEECDSAWITHAES256CBCSHA384 ApplicationGatewaySslCipherSuite = original.TLSECDHEECDSAWITHAES256CBCSHA384
+ TLSECDHEECDSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = original.TLSECDHEECDSAWITHAES256GCMSHA384
+ TLSECDHERSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = original.TLSECDHERSAWITHAES128CBCSHA
+ TLSECDHERSAWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = original.TLSECDHERSAWITHAES128CBCSHA256
+ TLSECDHERSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = original.TLSECDHERSAWITHAES128GCMSHA256
+ TLSECDHERSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = original.TLSECDHERSAWITHAES256CBCSHA
+ TLSECDHERSAWITHAES256CBCSHA384 ApplicationGatewaySslCipherSuite = original.TLSECDHERSAWITHAES256CBCSHA384
+ TLSECDHERSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = original.TLSECDHERSAWITHAES256GCMSHA384
+ TLSRSAWITH3DESEDECBCSHA ApplicationGatewaySslCipherSuite = original.TLSRSAWITH3DESEDECBCSHA
+ TLSRSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = original.TLSRSAWITHAES128CBCSHA
+ TLSRSAWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = original.TLSRSAWITHAES128CBCSHA256
+ TLSRSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = original.TLSRSAWITHAES128GCMSHA256
+ TLSRSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = original.TLSRSAWITHAES256CBCSHA
+ TLSRSAWITHAES256CBCSHA256 ApplicationGatewaySslCipherSuite = original.TLSRSAWITHAES256CBCSHA256
+ TLSRSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = original.TLSRSAWITHAES256GCMSHA384
+)
+
+type ApplicationGatewaySslPolicyName = original.ApplicationGatewaySslPolicyName
+
+const (
+ AppGwSslPolicy20150501 ApplicationGatewaySslPolicyName = original.AppGwSslPolicy20150501
+ AppGwSslPolicy20170401 ApplicationGatewaySslPolicyName = original.AppGwSslPolicy20170401
+ AppGwSslPolicy20170401S ApplicationGatewaySslPolicyName = original.AppGwSslPolicy20170401S
+)
+
+type ApplicationGatewaySslPolicyType = original.ApplicationGatewaySslPolicyType
+
+const (
+ Custom ApplicationGatewaySslPolicyType = original.Custom
+ Predefined ApplicationGatewaySslPolicyType = original.Predefined
+)
+
+type ApplicationGatewaySslProtocol = original.ApplicationGatewaySslProtocol
+
+const (
+ TLSv10 ApplicationGatewaySslProtocol = original.TLSv10
+ TLSv11 ApplicationGatewaySslProtocol = original.TLSv11
+ TLSv12 ApplicationGatewaySslProtocol = original.TLSv12
+)
+
+type ApplicationGatewayTier = original.ApplicationGatewayTier
+
+const (
+ Standard ApplicationGatewayTier = original.Standard
+ WAF ApplicationGatewayTier = original.WAF
+)
+
+type AssociationType = original.AssociationType
+
+const (
+ Associated AssociationType = original.Associated
+ Contains AssociationType = original.Contains
+)
+
+type AuthenticationMethod = original.AuthenticationMethod
+
+const (
+ EAPMSCHAPv2 AuthenticationMethod = original.EAPMSCHAPv2
+ EAPTLS AuthenticationMethod = original.EAPTLS
+)
+
+type AuthorizationUseStatus = original.AuthorizationUseStatus
+
+const (
+ Available AuthorizationUseStatus = original.Available
+ InUse AuthorizationUseStatus = original.InUse
+)
+
+type BgpPeerState = original.BgpPeerState
+
+const (
+ BgpPeerStateConnected BgpPeerState = original.BgpPeerStateConnected
+ BgpPeerStateConnecting BgpPeerState = original.BgpPeerStateConnecting
+ BgpPeerStateIdle BgpPeerState = original.BgpPeerStateIdle
+ BgpPeerStateStopped BgpPeerState = original.BgpPeerStateStopped
+ BgpPeerStateUnknown BgpPeerState = original.BgpPeerStateUnknown
+)
+
+type ConnectionState = original.ConnectionState
+
+const (
+ ConnectionStateReachable ConnectionState = original.ConnectionStateReachable
+ ConnectionStateUnknown ConnectionState = original.ConnectionStateUnknown
+ ConnectionStateUnreachable ConnectionState = original.ConnectionStateUnreachable
+)
+
+type ConnectionStatus = original.ConnectionStatus
+
+const (
+ ConnectionStatusConnected ConnectionStatus = original.ConnectionStatusConnected
+ ConnectionStatusDegraded ConnectionStatus = original.ConnectionStatusDegraded
+ ConnectionStatusDisconnected ConnectionStatus = original.ConnectionStatusDisconnected
+ ConnectionStatusUnknown ConnectionStatus = original.ConnectionStatusUnknown
+)
+
+type DhGroup = original.DhGroup
+
+const (
+ DHGroup1 DhGroup = original.DHGroup1
+ DHGroup14 DhGroup = original.DHGroup14
+ DHGroup2 DhGroup = original.DHGroup2
+ DHGroup2048 DhGroup = original.DHGroup2048
+ DHGroup24 DhGroup = original.DHGroup24
+ ECP256 DhGroup = original.ECP256
+ ECP384 DhGroup = original.ECP384
+ None DhGroup = original.None
+)
+
+type Direction = original.Direction
+
+const (
+ Inbound Direction = original.Inbound
+ Outbound Direction = original.Outbound
+)
+
+type EffectiveRouteSource = original.EffectiveRouteSource
+
+const (
+ EffectiveRouteSourceDefault EffectiveRouteSource = original.EffectiveRouteSourceDefault
+ EffectiveRouteSourceUnknown EffectiveRouteSource = original.EffectiveRouteSourceUnknown
+ EffectiveRouteSourceUser EffectiveRouteSource = original.EffectiveRouteSourceUser
+ EffectiveRouteSourceVirtualNetworkGateway EffectiveRouteSource = original.EffectiveRouteSourceVirtualNetworkGateway
+)
+
+type EffectiveRouteState = original.EffectiveRouteState
+
+const (
+ Active EffectiveRouteState = original.Active
+ Invalid EffectiveRouteState = original.Invalid
+)
+
+type EffectiveSecurityRuleProtocol = original.EffectiveSecurityRuleProtocol
+
+const (
+ All EffectiveSecurityRuleProtocol = original.All
+ TCP EffectiveSecurityRuleProtocol = original.TCP
+ UDP EffectiveSecurityRuleProtocol = original.UDP
+)
+
+type EvaluationState = original.EvaluationState
+
+const (
+ Completed EvaluationState = original.Completed
+ InProgress EvaluationState = original.InProgress
+ NotStarted EvaluationState = original.NotStarted
+)
+
+type ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = original.ExpressRouteCircuitPeeringAdvertisedPublicPrefixState
+
+const (
+ Configured ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = original.Configured
+ Configuring ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = original.Configuring
+ NotConfigured ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = original.NotConfigured
+ ValidationNeeded ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = original.ValidationNeeded
+)
+
+type ExpressRouteCircuitPeeringState = original.ExpressRouteCircuitPeeringState
+
+const (
+ ExpressRouteCircuitPeeringStateDisabled ExpressRouteCircuitPeeringState = original.ExpressRouteCircuitPeeringStateDisabled
+ ExpressRouteCircuitPeeringStateEnabled ExpressRouteCircuitPeeringState = original.ExpressRouteCircuitPeeringStateEnabled
+)
+
+type ExpressRouteCircuitPeeringType = original.ExpressRouteCircuitPeeringType
+
+const (
+ AzurePrivatePeering ExpressRouteCircuitPeeringType = original.AzurePrivatePeering
+ AzurePublicPeering ExpressRouteCircuitPeeringType = original.AzurePublicPeering
+ MicrosoftPeering ExpressRouteCircuitPeeringType = original.MicrosoftPeering
+)
+
+type ExpressRouteCircuitSkuFamily = original.ExpressRouteCircuitSkuFamily
+
+const (
+ MeteredData ExpressRouteCircuitSkuFamily = original.MeteredData
+ UnlimitedData ExpressRouteCircuitSkuFamily = original.UnlimitedData
+)
+
+type ExpressRouteCircuitSkuTier = original.ExpressRouteCircuitSkuTier
+
+const (
+ ExpressRouteCircuitSkuTierPremium ExpressRouteCircuitSkuTier = original.ExpressRouteCircuitSkuTierPremium
+ ExpressRouteCircuitSkuTierStandard ExpressRouteCircuitSkuTier = original.ExpressRouteCircuitSkuTierStandard
+)
+
+type IPAllocationMethod = original.IPAllocationMethod
+
+const (
+ Dynamic IPAllocationMethod = original.Dynamic
+ Static IPAllocationMethod = original.Static
+)
+
+type IPVersion = original.IPVersion
+
+const (
+ IPv4 IPVersion = original.IPv4
+ IPv6 IPVersion = original.IPv6
+)
+
+type IkeEncryption = original.IkeEncryption
+
+const (
+ AES128 IkeEncryption = original.AES128
+ AES192 IkeEncryption = original.AES192
+ AES256 IkeEncryption = original.AES256
+ DES IkeEncryption = original.DES
+ DES3 IkeEncryption = original.DES3
+)
+
+type IkeIntegrity = original.IkeIntegrity
+
+const (
+ MD5 IkeIntegrity = original.MD5
+ SHA1 IkeIntegrity = original.SHA1
+ SHA256 IkeIntegrity = original.SHA256
+ SHA384 IkeIntegrity = original.SHA384
+)
+
+type IpsecEncryption = original.IpsecEncryption
+
+const (
+ IpsecEncryptionAES128 IpsecEncryption = original.IpsecEncryptionAES128
+ IpsecEncryptionAES192 IpsecEncryption = original.IpsecEncryptionAES192
+ IpsecEncryptionAES256 IpsecEncryption = original.IpsecEncryptionAES256
+ IpsecEncryptionDES IpsecEncryption = original.IpsecEncryptionDES
+ IpsecEncryptionDES3 IpsecEncryption = original.IpsecEncryptionDES3
+ IpsecEncryptionGCMAES128 IpsecEncryption = original.IpsecEncryptionGCMAES128
+ IpsecEncryptionGCMAES192 IpsecEncryption = original.IpsecEncryptionGCMAES192
+ IpsecEncryptionGCMAES256 IpsecEncryption = original.IpsecEncryptionGCMAES256
+ IpsecEncryptionNone IpsecEncryption = original.IpsecEncryptionNone
+)
+
+type IpsecIntegrity = original.IpsecIntegrity
+
+const (
+ IpsecIntegrityGCMAES128 IpsecIntegrity = original.IpsecIntegrityGCMAES128
+ IpsecIntegrityGCMAES192 IpsecIntegrity = original.IpsecIntegrityGCMAES192
+ IpsecIntegrityGCMAES256 IpsecIntegrity = original.IpsecIntegrityGCMAES256
+ IpsecIntegrityMD5 IpsecIntegrity = original.IpsecIntegrityMD5
+ IpsecIntegritySHA1 IpsecIntegrity = original.IpsecIntegritySHA1
+ IpsecIntegritySHA256 IpsecIntegrity = original.IpsecIntegritySHA256
+)
+
+type IssueType = original.IssueType
+
+const (
+ IssueTypeAgentStopped IssueType = original.IssueTypeAgentStopped
+ IssueTypeDNSResolution IssueType = original.IssueTypeDNSResolution
+ IssueTypeGuestFirewall IssueType = original.IssueTypeGuestFirewall
+ IssueTypeNetworkSecurityRule IssueType = original.IssueTypeNetworkSecurityRule
+ IssueTypePlatform IssueType = original.IssueTypePlatform
+ IssueTypePortThrottled IssueType = original.IssueTypePortThrottled
+ IssueTypeSocketBind IssueType = original.IssueTypeSocketBind
+ IssueTypeUnknown IssueType = original.IssueTypeUnknown
+ IssueTypeUserDefinedRoute IssueType = original.IssueTypeUserDefinedRoute
+)
+
+type LoadBalancerSkuName = original.LoadBalancerSkuName
+
+const (
+ LoadBalancerSkuNameBasic LoadBalancerSkuName = original.LoadBalancerSkuNameBasic
+ LoadBalancerSkuNameStandard LoadBalancerSkuName = original.LoadBalancerSkuNameStandard
+)
+
+type LoadDistribution = original.LoadDistribution
+
+const (
+ Default LoadDistribution = original.Default
+ SourceIP LoadDistribution = original.SourceIP
+ SourceIPProtocol LoadDistribution = original.SourceIPProtocol
+)
+
+type NextHopType = original.NextHopType
+
+const (
+ NextHopTypeHyperNetGateway NextHopType = original.NextHopTypeHyperNetGateway
+ NextHopTypeInternet NextHopType = original.NextHopTypeInternet
+ NextHopTypeNone NextHopType = original.NextHopTypeNone
+ NextHopTypeVirtualAppliance NextHopType = original.NextHopTypeVirtualAppliance
+ NextHopTypeVirtualNetworkGateway NextHopType = original.NextHopTypeVirtualNetworkGateway
+ NextHopTypeVnetLocal NextHopType = original.NextHopTypeVnetLocal
+)
+
+type OperationStatus = original.OperationStatus
+
+const (
+ OperationStatusFailed OperationStatus = original.OperationStatusFailed
+ OperationStatusInProgress OperationStatus = original.OperationStatusInProgress
+ OperationStatusSucceeded OperationStatus = original.OperationStatusSucceeded
+)
+
+type Origin = original.Origin
+
+const (
+ OriginInbound Origin = original.OriginInbound
+ OriginLocal Origin = original.OriginLocal
+ OriginOutbound Origin = original.OriginOutbound
+)
+
+type PcError = original.PcError
+
+const (
+ AgentStopped PcError = original.AgentStopped
+ CaptureFailed PcError = original.CaptureFailed
+ InternalError PcError = original.InternalError
+ LocalFileFailed PcError = original.LocalFileFailed
+ StorageFailed PcError = original.StorageFailed
+)
+
+type PcProtocol = original.PcProtocol
+
+const (
+ PcProtocolAny PcProtocol = original.PcProtocolAny
+ PcProtocolTCP PcProtocol = original.PcProtocolTCP
+ PcProtocolUDP PcProtocol = original.PcProtocolUDP
+)
+
+type PcStatus = original.PcStatus
+
+const (
+ PcStatusError PcStatus = original.PcStatusError
+ PcStatusNotStarted PcStatus = original.PcStatusNotStarted
+ PcStatusRunning PcStatus = original.PcStatusRunning
+ PcStatusStopped PcStatus = original.PcStatusStopped
+ PcStatusUnknown PcStatus = original.PcStatusUnknown
+)
+
+type PfsGroup = original.PfsGroup
+
+const (
+ PfsGroupECP256 PfsGroup = original.PfsGroupECP256
+ PfsGroupECP384 PfsGroup = original.PfsGroupECP384
+ PfsGroupNone PfsGroup = original.PfsGroupNone
+ PfsGroupPFS1 PfsGroup = original.PfsGroupPFS1
+ PfsGroupPFS2 PfsGroup = original.PfsGroupPFS2
+ PfsGroupPFS2048 PfsGroup = original.PfsGroupPFS2048
+ PfsGroupPFS24 PfsGroup = original.PfsGroupPFS24
+)
+
+type ProbeProtocol = original.ProbeProtocol
+
+const (
+ ProbeProtocolHTTP ProbeProtocol = original.ProbeProtocolHTTP
+ ProbeProtocolTCP ProbeProtocol = original.ProbeProtocolTCP
+)
+
+type ProcessorArchitecture = original.ProcessorArchitecture
+
+const (
+ Amd64 ProcessorArchitecture = original.Amd64
+ X86 ProcessorArchitecture = original.X86
+)
+
+type Protocol = original.Protocol
+
+const (
+ ProtocolTCP Protocol = original.ProtocolTCP
+ ProtocolUDP Protocol = original.ProtocolUDP
+)
+
+type ProvisioningState = original.ProvisioningState
+
+const (
+ Deleting ProvisioningState = original.Deleting
+ Failed ProvisioningState = original.Failed
+ Succeeded ProvisioningState = original.Succeeded
+ Updating ProvisioningState = original.Updating
+)
+
+type PublicIPAddressSkuName = original.PublicIPAddressSkuName
+
+const (
+ PublicIPAddressSkuNameBasic PublicIPAddressSkuName = original.PublicIPAddressSkuNameBasic
+ PublicIPAddressSkuNameStandard PublicIPAddressSkuName = original.PublicIPAddressSkuNameStandard
+)
+
+type RouteNextHopType = original.RouteNextHopType
+
+const (
+ RouteNextHopTypeInternet RouteNextHopType = original.RouteNextHopTypeInternet
+ RouteNextHopTypeNone RouteNextHopType = original.RouteNextHopTypeNone
+ RouteNextHopTypeVirtualAppliance RouteNextHopType = original.RouteNextHopTypeVirtualAppliance
+ RouteNextHopTypeVirtualNetworkGateway RouteNextHopType = original.RouteNextHopTypeVirtualNetworkGateway
+ RouteNextHopTypeVnetLocal RouteNextHopType = original.RouteNextHopTypeVnetLocal
+)
+
+type SecurityRuleAccess = original.SecurityRuleAccess
+
+const (
+ SecurityRuleAccessAllow SecurityRuleAccess = original.SecurityRuleAccessAllow
+ SecurityRuleAccessDeny SecurityRuleAccess = original.SecurityRuleAccessDeny
+)
+
+type SecurityRuleDirection = original.SecurityRuleDirection
+
+const (
+ SecurityRuleDirectionInbound SecurityRuleDirection = original.SecurityRuleDirectionInbound
+ SecurityRuleDirectionOutbound SecurityRuleDirection = original.SecurityRuleDirectionOutbound
+)
+
+type SecurityRuleProtocol = original.SecurityRuleProtocol
+
+const (
+ SecurityRuleProtocolAsterisk SecurityRuleProtocol = original.SecurityRuleProtocolAsterisk
+ SecurityRuleProtocolTCP SecurityRuleProtocol = original.SecurityRuleProtocolTCP
+ SecurityRuleProtocolUDP SecurityRuleProtocol = original.SecurityRuleProtocolUDP
+)
+
+type ServiceProviderProvisioningState = original.ServiceProviderProvisioningState
+
+const (
+ Deprovisioning ServiceProviderProvisioningState = original.Deprovisioning
+ NotProvisioned ServiceProviderProvisioningState = original.NotProvisioned
+ Provisioned ServiceProviderProvisioningState = original.Provisioned
+ Provisioning ServiceProviderProvisioningState = original.Provisioning
+)
+
+type Severity = original.Severity
+
+const (
+ SeverityError Severity = original.SeverityError
+ SeverityWarning Severity = original.SeverityWarning
+)
+
+type TransportProtocol = original.TransportProtocol
+
+const (
+ TransportProtocolAll TransportProtocol = original.TransportProtocolAll
+ TransportProtocolTCP TransportProtocol = original.TransportProtocolTCP
+ TransportProtocolUDP TransportProtocol = original.TransportProtocolUDP
+)
+
+type VirtualNetworkGatewayConnectionStatus = original.VirtualNetworkGatewayConnectionStatus
+
+const (
+ VirtualNetworkGatewayConnectionStatusConnected VirtualNetworkGatewayConnectionStatus = original.VirtualNetworkGatewayConnectionStatusConnected
+ VirtualNetworkGatewayConnectionStatusConnecting VirtualNetworkGatewayConnectionStatus = original.VirtualNetworkGatewayConnectionStatusConnecting
+ VirtualNetworkGatewayConnectionStatusNotConnected VirtualNetworkGatewayConnectionStatus = original.VirtualNetworkGatewayConnectionStatusNotConnected
+ VirtualNetworkGatewayConnectionStatusUnknown VirtualNetworkGatewayConnectionStatus = original.VirtualNetworkGatewayConnectionStatusUnknown
+)
+
+type VirtualNetworkGatewayConnectionType = original.VirtualNetworkGatewayConnectionType
+
+const (
+ ExpressRoute VirtualNetworkGatewayConnectionType = original.ExpressRoute
+ IPsec VirtualNetworkGatewayConnectionType = original.IPsec
+ Vnet2Vnet VirtualNetworkGatewayConnectionType = original.Vnet2Vnet
+ VPNClient VirtualNetworkGatewayConnectionType = original.VPNClient
+)
+
+type VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuName
+
+const (
+ VirtualNetworkGatewaySkuNameBasic VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuNameBasic
+ VirtualNetworkGatewaySkuNameHighPerformance VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuNameHighPerformance
+ VirtualNetworkGatewaySkuNameStandard VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuNameStandard
+ VirtualNetworkGatewaySkuNameUltraPerformance VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuNameUltraPerformance
+ VirtualNetworkGatewaySkuNameVpnGw1 VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuNameVpnGw1
+ VirtualNetworkGatewaySkuNameVpnGw2 VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuNameVpnGw2
+ VirtualNetworkGatewaySkuNameVpnGw3 VirtualNetworkGatewaySkuName = original.VirtualNetworkGatewaySkuNameVpnGw3
+)
+
+type VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTier
+
+const (
+ VirtualNetworkGatewaySkuTierBasic VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTierBasic
+ VirtualNetworkGatewaySkuTierHighPerformance VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTierHighPerformance
+ VirtualNetworkGatewaySkuTierStandard VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTierStandard
+ VirtualNetworkGatewaySkuTierUltraPerformance VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTierUltraPerformance
+ VirtualNetworkGatewaySkuTierVpnGw1 VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTierVpnGw1
+ VirtualNetworkGatewaySkuTierVpnGw2 VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTierVpnGw2
+ VirtualNetworkGatewaySkuTierVpnGw3 VirtualNetworkGatewaySkuTier = original.VirtualNetworkGatewaySkuTierVpnGw3
+)
+
+type VirtualNetworkGatewayType = original.VirtualNetworkGatewayType
+
+const (
+ VirtualNetworkGatewayTypeExpressRoute VirtualNetworkGatewayType = original.VirtualNetworkGatewayTypeExpressRoute
+ VirtualNetworkGatewayTypeVpn VirtualNetworkGatewayType = original.VirtualNetworkGatewayTypeVpn
+)
+
+type VirtualNetworkPeeringState = original.VirtualNetworkPeeringState
+
+const (
+ Connected VirtualNetworkPeeringState = original.Connected
+ Disconnected VirtualNetworkPeeringState = original.Disconnected
+ Initiated VirtualNetworkPeeringState = original.Initiated
+)
+
+type VpnClientProtocol = original.VpnClientProtocol
+
+const (
+ IkeV2 VpnClientProtocol = original.IkeV2
+ SSTP VpnClientProtocol = original.SSTP
+)
+
+type VpnType = original.VpnType
+
+const (
+ PolicyBased VpnType = original.PolicyBased
+ RouteBased VpnType = original.RouteBased
+)
+
+type AddressSpace = original.AddressSpace
+type ApplicationGateway = original.ApplicationGateway
+type ApplicationGatewayAuthenticationCertificate = original.ApplicationGatewayAuthenticationCertificate
+type ApplicationGatewayAuthenticationCertificatePropertiesFormat = original.ApplicationGatewayAuthenticationCertificatePropertiesFormat
+type ApplicationGatewayAvailableSslOptions = original.ApplicationGatewayAvailableSslOptions
+type ApplicationGatewayAvailableSslOptionsPropertiesFormat = original.ApplicationGatewayAvailableSslOptionsPropertiesFormat
+type ApplicationGatewayAvailableSslPredefinedPolicies = original.ApplicationGatewayAvailableSslPredefinedPolicies
+type ApplicationGatewayAvailableSslPredefinedPoliciesIterator = original.ApplicationGatewayAvailableSslPredefinedPoliciesIterator
+type ApplicationGatewayAvailableSslPredefinedPoliciesPage = original.ApplicationGatewayAvailableSslPredefinedPoliciesPage
+type ApplicationGatewayAvailableWafRuleSetsResult = original.ApplicationGatewayAvailableWafRuleSetsResult
+type ApplicationGatewayBackendAddress = original.ApplicationGatewayBackendAddress
+type ApplicationGatewayBackendAddressPool = original.ApplicationGatewayBackendAddressPool
+type ApplicationGatewayBackendAddressPoolPropertiesFormat = original.ApplicationGatewayBackendAddressPoolPropertiesFormat
+type ApplicationGatewayBackendHTTPSettings = original.ApplicationGatewayBackendHTTPSettings
+type ApplicationGatewayBackendHTTPSettingsPropertiesFormat = original.ApplicationGatewayBackendHTTPSettingsPropertiesFormat
+type ApplicationGatewayBackendHealth = original.ApplicationGatewayBackendHealth
+type ApplicationGatewayBackendHealthHTTPSettings = original.ApplicationGatewayBackendHealthHTTPSettings
+type ApplicationGatewayBackendHealthPool = original.ApplicationGatewayBackendHealthPool
+type ApplicationGatewayBackendHealthServer = original.ApplicationGatewayBackendHealthServer
+type ApplicationGatewayConnectionDraining = original.ApplicationGatewayConnectionDraining
+type ApplicationGatewayFirewallDisabledRuleGroup = original.ApplicationGatewayFirewallDisabledRuleGroup
+type ApplicationGatewayFirewallRule = original.ApplicationGatewayFirewallRule
+type ApplicationGatewayFirewallRuleGroup = original.ApplicationGatewayFirewallRuleGroup
+type ApplicationGatewayFirewallRuleSet = original.ApplicationGatewayFirewallRuleSet
+type ApplicationGatewayFirewallRuleSetPropertiesFormat = original.ApplicationGatewayFirewallRuleSetPropertiesFormat
+type ApplicationGatewayFrontendIPConfiguration = original.ApplicationGatewayFrontendIPConfiguration
+type ApplicationGatewayFrontendIPConfigurationPropertiesFormat = original.ApplicationGatewayFrontendIPConfigurationPropertiesFormat
+type ApplicationGatewayFrontendPort = original.ApplicationGatewayFrontendPort
+type ApplicationGatewayFrontendPortPropertiesFormat = original.ApplicationGatewayFrontendPortPropertiesFormat
+type ApplicationGatewayHTTPListener = original.ApplicationGatewayHTTPListener
+type ApplicationGatewayHTTPListenerPropertiesFormat = original.ApplicationGatewayHTTPListenerPropertiesFormat
+type ApplicationGatewayIPConfiguration = original.ApplicationGatewayIPConfiguration
+type ApplicationGatewayIPConfigurationPropertiesFormat = original.ApplicationGatewayIPConfigurationPropertiesFormat
+type ApplicationGatewayListResult = original.ApplicationGatewayListResult
+type ApplicationGatewayListResultIterator = original.ApplicationGatewayListResultIterator
+type ApplicationGatewayListResultPage = original.ApplicationGatewayListResultPage
+type ApplicationGatewayPathRule = original.ApplicationGatewayPathRule
+type ApplicationGatewayPathRulePropertiesFormat = original.ApplicationGatewayPathRulePropertiesFormat
+type ApplicationGatewayProbe = original.ApplicationGatewayProbe
+type ApplicationGatewayProbeHealthResponseMatch = original.ApplicationGatewayProbeHealthResponseMatch
+type ApplicationGatewayProbePropertiesFormat = original.ApplicationGatewayProbePropertiesFormat
+type ApplicationGatewayPropertiesFormat = original.ApplicationGatewayPropertiesFormat
+type ApplicationGatewayRedirectConfiguration = original.ApplicationGatewayRedirectConfiguration
+type ApplicationGatewayRedirectConfigurationPropertiesFormat = original.ApplicationGatewayRedirectConfigurationPropertiesFormat
+type ApplicationGatewayRequestRoutingRule = original.ApplicationGatewayRequestRoutingRule
+type ApplicationGatewayRequestRoutingRulePropertiesFormat = original.ApplicationGatewayRequestRoutingRulePropertiesFormat
+type ApplicationGatewaySku = original.ApplicationGatewaySku
+type ApplicationGatewaySslCertificate = original.ApplicationGatewaySslCertificate
+type ApplicationGatewaySslCertificatePropertiesFormat = original.ApplicationGatewaySslCertificatePropertiesFormat
+type ApplicationGatewaySslPolicy = original.ApplicationGatewaySslPolicy
+type ApplicationGatewaySslPredefinedPolicy = original.ApplicationGatewaySslPredefinedPolicy
+type ApplicationGatewaySslPredefinedPolicyPropertiesFormat = original.ApplicationGatewaySslPredefinedPolicyPropertiesFormat
+type ApplicationGatewayURLPathMap = original.ApplicationGatewayURLPathMap
+type ApplicationGatewayURLPathMapPropertiesFormat = original.ApplicationGatewayURLPathMapPropertiesFormat
+type ApplicationGatewayWebApplicationFirewallConfiguration = original.ApplicationGatewayWebApplicationFirewallConfiguration
+type ApplicationGatewaysBackendHealthFuture = original.ApplicationGatewaysBackendHealthFuture
+type ApplicationGatewaysClient = original.ApplicationGatewaysClient
+type ApplicationGatewaysCreateOrUpdateFuture = original.ApplicationGatewaysCreateOrUpdateFuture
+type ApplicationGatewaysDeleteFuture = original.ApplicationGatewaysDeleteFuture
+type ApplicationGatewaysStartFuture = original.ApplicationGatewaysStartFuture
+type ApplicationGatewaysStopFuture = original.ApplicationGatewaysStopFuture
+type ApplicationGatewaysUpdateTagsFuture = original.ApplicationGatewaysUpdateTagsFuture
+type ApplicationSecurityGroup = original.ApplicationSecurityGroup
+type ApplicationSecurityGroupListResult = original.ApplicationSecurityGroupListResult
+type ApplicationSecurityGroupListResultIterator = original.ApplicationSecurityGroupListResultIterator
+type ApplicationSecurityGroupListResultPage = original.ApplicationSecurityGroupListResultPage
+type ApplicationSecurityGroupPropertiesFormat = original.ApplicationSecurityGroupPropertiesFormat
+type ApplicationSecurityGroupsClient = original.ApplicationSecurityGroupsClient
+type ApplicationSecurityGroupsCreateOrUpdateFuture = original.ApplicationSecurityGroupsCreateOrUpdateFuture
+type ApplicationSecurityGroupsDeleteFuture = original.ApplicationSecurityGroupsDeleteFuture
+type AuthorizationListResult = original.AuthorizationListResult
+type AuthorizationListResultIterator = original.AuthorizationListResultIterator
+type AuthorizationListResultPage = original.AuthorizationListResultPage
+type AuthorizationPropertiesFormat = original.AuthorizationPropertiesFormat
+type Availability = original.Availability
+type AvailableEndpointServicesClient = original.AvailableEndpointServicesClient
+type AvailableProvidersList = original.AvailableProvidersList
+type AvailableProvidersListCity = original.AvailableProvidersListCity
+type AvailableProvidersListCountry = original.AvailableProvidersListCountry
+type AvailableProvidersListParameters = original.AvailableProvidersListParameters
+type AvailableProvidersListState = original.AvailableProvidersListState
+type AzureAsyncOperationResult = original.AzureAsyncOperationResult
+type AzureReachabilityReport = original.AzureReachabilityReport
+type AzureReachabilityReportItem = original.AzureReachabilityReportItem
+type AzureReachabilityReportLatencyInfo = original.AzureReachabilityReportLatencyInfo
+type AzureReachabilityReportLocation = original.AzureReachabilityReportLocation
+type AzureReachabilityReportParameters = original.AzureReachabilityReportParameters
+type BGPCommunity = original.BGPCommunity
+type BackendAddressPool = original.BackendAddressPool
+type BackendAddressPoolPropertiesFormat = original.BackendAddressPoolPropertiesFormat
+type BaseClient = original.BaseClient
+type BgpPeerStatus = original.BgpPeerStatus
+type BgpPeerStatusListResult = original.BgpPeerStatusListResult
+type BgpServiceCommunitiesClient = original.BgpServiceCommunitiesClient
+type BgpServiceCommunity = original.BgpServiceCommunity
+type BgpServiceCommunityListResult = original.BgpServiceCommunityListResult
+type BgpServiceCommunityListResultIterator = original.BgpServiceCommunityListResultIterator
+type BgpServiceCommunityListResultPage = original.BgpServiceCommunityListResultPage
+type BgpServiceCommunityPropertiesFormat = original.BgpServiceCommunityPropertiesFormat
+type BgpSettings = original.BgpSettings
+type ConnectionMonitor = original.ConnectionMonitor
+type ConnectionMonitorDestination = original.ConnectionMonitorDestination
+type ConnectionMonitorListResult = original.ConnectionMonitorListResult
+type ConnectionMonitorParameters = original.ConnectionMonitorParameters
+type ConnectionMonitorQueryResult = original.ConnectionMonitorQueryResult
+type ConnectionMonitorResult = original.ConnectionMonitorResult
+type ConnectionMonitorResultProperties = original.ConnectionMonitorResultProperties
+type ConnectionMonitorSource = original.ConnectionMonitorSource
+type ConnectionMonitorsClient = original.ConnectionMonitorsClient
+type ConnectionMonitorsCreateOrUpdateFuture = original.ConnectionMonitorsCreateOrUpdateFuture
+type ConnectionMonitorsDeleteFuture = original.ConnectionMonitorsDeleteFuture
+type ConnectionMonitorsQueryFuture = original.ConnectionMonitorsQueryFuture
+type ConnectionMonitorsStartFuture = original.ConnectionMonitorsStartFuture
+type ConnectionMonitorsStopFuture = original.ConnectionMonitorsStopFuture
+type ConnectionResetSharedKey = original.ConnectionResetSharedKey
+type ConnectionSharedKey = original.ConnectionSharedKey
+type ConnectionStateSnapshot = original.ConnectionStateSnapshot
+type ConnectivityDestination = original.ConnectivityDestination
+type ConnectivityHop = original.ConnectivityHop
+type ConnectivityInformation = original.ConnectivityInformation
+type ConnectivityIssue = original.ConnectivityIssue
+type ConnectivityParameters = original.ConnectivityParameters
+type ConnectivitySource = original.ConnectivitySource
+type DNSNameAvailabilityResult = original.DNSNameAvailabilityResult
+type DefaultSecurityRulesClient = original.DefaultSecurityRulesClient
+type DhcpOptions = original.DhcpOptions
+type Dimension = original.Dimension
+type EffectiveNetworkSecurityGroup = original.EffectiveNetworkSecurityGroup
+type EffectiveNetworkSecurityGroupAssociation = original.EffectiveNetworkSecurityGroupAssociation
+type EffectiveNetworkSecurityGroupListResult = original.EffectiveNetworkSecurityGroupListResult
+type EffectiveNetworkSecurityRule = original.EffectiveNetworkSecurityRule
+type EffectiveRoute = original.EffectiveRoute
+type EffectiveRouteListResult = original.EffectiveRouteListResult
+type EndpointServiceResult = original.EndpointServiceResult
+type EndpointServicesListResult = original.EndpointServicesListResult
+type EndpointServicesListResultIterator = original.EndpointServicesListResultIterator
+type EndpointServicesListResultPage = original.EndpointServicesListResultPage
+type Error = original.Error
+type ErrorDetails = original.ErrorDetails
+type ExpressRouteCircuit = original.ExpressRouteCircuit
+type ExpressRouteCircuitArpTable = original.ExpressRouteCircuitArpTable
+type ExpressRouteCircuitAuthorization = original.ExpressRouteCircuitAuthorization
+type ExpressRouteCircuitAuthorizationsClient = original.ExpressRouteCircuitAuthorizationsClient
+type ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture = original.ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture
+type ExpressRouteCircuitAuthorizationsDeleteFuture = original.ExpressRouteCircuitAuthorizationsDeleteFuture
+type ExpressRouteCircuitListResult = original.ExpressRouteCircuitListResult
+type ExpressRouteCircuitListResultIterator = original.ExpressRouteCircuitListResultIterator
+type ExpressRouteCircuitListResultPage = original.ExpressRouteCircuitListResultPage
+type ExpressRouteCircuitPeering = original.ExpressRouteCircuitPeering
+type ExpressRouteCircuitPeeringConfig = original.ExpressRouteCircuitPeeringConfig
+type ExpressRouteCircuitPeeringListResult = original.ExpressRouteCircuitPeeringListResult
+type ExpressRouteCircuitPeeringListResultIterator = original.ExpressRouteCircuitPeeringListResultIterator
+type ExpressRouteCircuitPeeringListResultPage = original.ExpressRouteCircuitPeeringListResultPage
+type ExpressRouteCircuitPeeringPropertiesFormat = original.ExpressRouteCircuitPeeringPropertiesFormat
+type ExpressRouteCircuitPeeringsClient = original.ExpressRouteCircuitPeeringsClient
+type ExpressRouteCircuitPeeringsCreateOrUpdateFuture = original.ExpressRouteCircuitPeeringsCreateOrUpdateFuture
+type ExpressRouteCircuitPeeringsDeleteFuture = original.ExpressRouteCircuitPeeringsDeleteFuture
+type ExpressRouteCircuitPropertiesFormat = original.ExpressRouteCircuitPropertiesFormat
+type ExpressRouteCircuitRoutesTable = original.ExpressRouteCircuitRoutesTable
+type ExpressRouteCircuitRoutesTableSummary = original.ExpressRouteCircuitRoutesTableSummary
+type ExpressRouteCircuitServiceProviderProperties = original.ExpressRouteCircuitServiceProviderProperties
+type ExpressRouteCircuitSku = original.ExpressRouteCircuitSku
+type ExpressRouteCircuitStats = original.ExpressRouteCircuitStats
+type ExpressRouteCircuitsArpTableListResult = original.ExpressRouteCircuitsArpTableListResult
+type ExpressRouteCircuitsClient = original.ExpressRouteCircuitsClient
+type ExpressRouteCircuitsCreateOrUpdateFuture = original.ExpressRouteCircuitsCreateOrUpdateFuture
+type ExpressRouteCircuitsDeleteFuture = original.ExpressRouteCircuitsDeleteFuture
+type ExpressRouteCircuitsListArpTableFuture = original.ExpressRouteCircuitsListArpTableFuture
+type ExpressRouteCircuitsListRoutesTableFuture = original.ExpressRouteCircuitsListRoutesTableFuture
+type ExpressRouteCircuitsListRoutesTableSummaryFuture = original.ExpressRouteCircuitsListRoutesTableSummaryFuture
+type ExpressRouteCircuitsRoutesTableListResult = original.ExpressRouteCircuitsRoutesTableListResult
+type ExpressRouteCircuitsRoutesTableSummaryListResult = original.ExpressRouteCircuitsRoutesTableSummaryListResult
+type ExpressRouteCircuitsUpdateTagsFuture = original.ExpressRouteCircuitsUpdateTagsFuture
+type ExpressRouteServiceProvider = original.ExpressRouteServiceProvider
+type ExpressRouteServiceProviderBandwidthsOffered = original.ExpressRouteServiceProviderBandwidthsOffered
+type ExpressRouteServiceProviderListResult = original.ExpressRouteServiceProviderListResult
+type ExpressRouteServiceProviderListResultIterator = original.ExpressRouteServiceProviderListResultIterator
+type ExpressRouteServiceProviderListResultPage = original.ExpressRouteServiceProviderListResultPage
+type ExpressRouteServiceProviderPropertiesFormat = original.ExpressRouteServiceProviderPropertiesFormat
+type ExpressRouteServiceProvidersClient = original.ExpressRouteServiceProvidersClient
+type FlowLogInformation = original.FlowLogInformation
+type FlowLogProperties = original.FlowLogProperties
+type FlowLogStatusParameters = original.FlowLogStatusParameters
+type FrontendIPConfiguration = original.FrontendIPConfiguration
+type FrontendIPConfigurationPropertiesFormat = original.FrontendIPConfigurationPropertiesFormat
+type GatewayRoute = original.GatewayRoute
+type GatewayRouteListResult = original.GatewayRouteListResult
+type IPAddressAvailabilityResult = original.IPAddressAvailabilityResult
+type IPConfiguration = original.IPConfiguration
+type IPConfigurationPropertiesFormat = original.IPConfigurationPropertiesFormat
+type InboundNatPool = original.InboundNatPool
+type InboundNatPoolPropertiesFormat = original.InboundNatPoolPropertiesFormat
+type InboundNatRule = original.InboundNatRule
+type InboundNatRuleListResult = original.InboundNatRuleListResult
+type InboundNatRuleListResultIterator = original.InboundNatRuleListResultIterator
+type InboundNatRuleListResultPage = original.InboundNatRuleListResultPage
+type InboundNatRulePropertiesFormat = original.InboundNatRulePropertiesFormat
+type InboundNatRulesClient = original.InboundNatRulesClient
+type InboundNatRulesCreateOrUpdateFuture = original.InboundNatRulesCreateOrUpdateFuture
+type InboundNatRulesDeleteFuture = original.InboundNatRulesDeleteFuture
+type Interface = original.Interface
+type InterfaceAssociation = original.InterfaceAssociation
+type InterfaceDNSSettings = original.InterfaceDNSSettings
+type InterfaceIPConfiguration = original.InterfaceIPConfiguration
+type InterfaceIPConfigurationListResult = original.InterfaceIPConfigurationListResult
+type InterfaceIPConfigurationListResultIterator = original.InterfaceIPConfigurationListResultIterator
+type InterfaceIPConfigurationListResultPage = original.InterfaceIPConfigurationListResultPage
+type InterfaceIPConfigurationPropertiesFormat = original.InterfaceIPConfigurationPropertiesFormat
+type InterfaceIPConfigurationsClient = original.InterfaceIPConfigurationsClient
+type InterfaceListResult = original.InterfaceListResult
+type InterfaceListResultIterator = original.InterfaceListResultIterator
+type InterfaceListResultPage = original.InterfaceListResultPage
+type InterfaceLoadBalancerListResult = original.InterfaceLoadBalancerListResult
+type InterfaceLoadBalancerListResultIterator = original.InterfaceLoadBalancerListResultIterator
+type InterfaceLoadBalancerListResultPage = original.InterfaceLoadBalancerListResultPage
+type InterfaceLoadBalancersClient = original.InterfaceLoadBalancersClient
+type InterfacePropertiesFormat = original.InterfacePropertiesFormat
+type InterfacesClient = original.InterfacesClient
+type InterfacesCreateOrUpdateFuture = original.InterfacesCreateOrUpdateFuture
+type InterfacesDeleteFuture = original.InterfacesDeleteFuture
+type InterfacesGetEffectiveRouteTableFuture = original.InterfacesGetEffectiveRouteTableFuture
+type InterfacesListEffectiveNetworkSecurityGroupsFuture = original.InterfacesListEffectiveNetworkSecurityGroupsFuture
+type InterfacesUpdateTagsFuture = original.InterfacesUpdateTagsFuture
+type IpsecPolicy = original.IpsecPolicy
+type Ipv6ExpressRouteCircuitPeeringConfig = original.Ipv6ExpressRouteCircuitPeeringConfig
+type LoadBalancer = original.LoadBalancer
+type LoadBalancerBackendAddressPoolListResult = original.LoadBalancerBackendAddressPoolListResult
+type LoadBalancerBackendAddressPoolListResultIterator = original.LoadBalancerBackendAddressPoolListResultIterator
+type LoadBalancerBackendAddressPoolListResultPage = original.LoadBalancerBackendAddressPoolListResultPage
+type LoadBalancerBackendAddressPoolsClient = original.LoadBalancerBackendAddressPoolsClient
+type LoadBalancerFrontendIPConfigurationListResult = original.LoadBalancerFrontendIPConfigurationListResult
+type LoadBalancerFrontendIPConfigurationListResultIterator = original.LoadBalancerFrontendIPConfigurationListResultIterator
+type LoadBalancerFrontendIPConfigurationListResultPage = original.LoadBalancerFrontendIPConfigurationListResultPage
+type LoadBalancerFrontendIPConfigurationsClient = original.LoadBalancerFrontendIPConfigurationsClient
+type LoadBalancerListResult = original.LoadBalancerListResult
+type LoadBalancerListResultIterator = original.LoadBalancerListResultIterator
+type LoadBalancerListResultPage = original.LoadBalancerListResultPage
+type LoadBalancerLoadBalancingRuleListResult = original.LoadBalancerLoadBalancingRuleListResult
+type LoadBalancerLoadBalancingRuleListResultIterator = original.LoadBalancerLoadBalancingRuleListResultIterator
+type LoadBalancerLoadBalancingRuleListResultPage = original.LoadBalancerLoadBalancingRuleListResultPage
+type LoadBalancerLoadBalancingRulesClient = original.LoadBalancerLoadBalancingRulesClient
+type LoadBalancerNetworkInterfacesClient = original.LoadBalancerNetworkInterfacesClient
+type LoadBalancerProbeListResult = original.LoadBalancerProbeListResult
+type LoadBalancerProbeListResultIterator = original.LoadBalancerProbeListResultIterator
+type LoadBalancerProbeListResultPage = original.LoadBalancerProbeListResultPage
+type LoadBalancerProbesClient = original.LoadBalancerProbesClient
+type LoadBalancerPropertiesFormat = original.LoadBalancerPropertiesFormat
+type LoadBalancerSku = original.LoadBalancerSku
+type LoadBalancersClient = original.LoadBalancersClient
+type LoadBalancersCreateOrUpdateFuture = original.LoadBalancersCreateOrUpdateFuture
+type LoadBalancersDeleteFuture = original.LoadBalancersDeleteFuture
+type LoadBalancersUpdateTagsFuture = original.LoadBalancersUpdateTagsFuture
+type LoadBalancingRule = original.LoadBalancingRule
+type LoadBalancingRulePropertiesFormat = original.LoadBalancingRulePropertiesFormat
+type LocalNetworkGateway = original.LocalNetworkGateway
+type LocalNetworkGatewayListResult = original.LocalNetworkGatewayListResult
+type LocalNetworkGatewayListResultIterator = original.LocalNetworkGatewayListResultIterator
+type LocalNetworkGatewayListResultPage = original.LocalNetworkGatewayListResultPage
+type LocalNetworkGatewayPropertiesFormat = original.LocalNetworkGatewayPropertiesFormat
+type LocalNetworkGatewaysClient = original.LocalNetworkGatewaysClient
+type LocalNetworkGatewaysCreateOrUpdateFuture = original.LocalNetworkGatewaysCreateOrUpdateFuture
+type LocalNetworkGatewaysDeleteFuture = original.LocalNetworkGatewaysDeleteFuture
+type LocalNetworkGatewaysUpdateTagsFuture = original.LocalNetworkGatewaysUpdateTagsFuture
+type LogSpecification = original.LogSpecification
+type MetricSpecification = original.MetricSpecification
+type NextHopParameters = original.NextHopParameters
+type NextHopResult = original.NextHopResult
+type Operation = original.Operation
+type OperationDisplay = original.OperationDisplay
+type OperationListResult = original.OperationListResult
+type OperationListResultIterator = original.OperationListResultIterator
+type OperationListResultPage = original.OperationListResultPage
+type OperationPropertiesFormat = original.OperationPropertiesFormat
+type OperationPropertiesFormatServiceSpecification = original.OperationPropertiesFormatServiceSpecification
+type OperationsClient = original.OperationsClient
+type OutboundNatRule = original.OutboundNatRule
+type OutboundNatRulePropertiesFormat = original.OutboundNatRulePropertiesFormat
+type PacketCapture = original.PacketCapture
+type PacketCaptureFilter = original.PacketCaptureFilter
+type PacketCaptureListResult = original.PacketCaptureListResult
+type PacketCaptureParameters = original.PacketCaptureParameters
+type PacketCaptureQueryStatusResult = original.PacketCaptureQueryStatusResult
+type PacketCaptureResult = original.PacketCaptureResult
+type PacketCaptureResultProperties = original.PacketCaptureResultProperties
+type PacketCaptureStorageLocation = original.PacketCaptureStorageLocation
+type PacketCapturesClient = original.PacketCapturesClient
+type PacketCapturesCreateFuture = original.PacketCapturesCreateFuture
+type PacketCapturesDeleteFuture = original.PacketCapturesDeleteFuture
+type PacketCapturesGetStatusFuture = original.PacketCapturesGetStatusFuture
+type PacketCapturesStopFuture = original.PacketCapturesStopFuture
+type PatchRouteFilter = original.PatchRouteFilter
+type PatchRouteFilterRule = original.PatchRouteFilterRule
+type Probe = original.Probe
+type ProbePropertiesFormat = original.ProbePropertiesFormat
+type PublicIPAddress = original.PublicIPAddress
+type PublicIPAddressDNSSettings = original.PublicIPAddressDNSSettings
+type PublicIPAddressListResult = original.PublicIPAddressListResult
+type PublicIPAddressListResultIterator = original.PublicIPAddressListResultIterator
+type PublicIPAddressListResultPage = original.PublicIPAddressListResultPage
+type PublicIPAddressPropertiesFormat = original.PublicIPAddressPropertiesFormat
+type PublicIPAddressSku = original.PublicIPAddressSku
+type PublicIPAddressesClient = original.PublicIPAddressesClient
+type PublicIPAddressesCreateOrUpdateFuture = original.PublicIPAddressesCreateOrUpdateFuture
+type PublicIPAddressesDeleteFuture = original.PublicIPAddressesDeleteFuture
+type PublicIPAddressesUpdateTagsFuture = original.PublicIPAddressesUpdateTagsFuture
+type QueryTroubleshootingParameters = original.QueryTroubleshootingParameters
+type Resource = original.Resource
+type ResourceNavigationLink = original.ResourceNavigationLink
+type ResourceNavigationLinkFormat = original.ResourceNavigationLinkFormat
+type RetentionPolicyParameters = original.RetentionPolicyParameters
+type Route = original.Route
+type RouteFilter = original.RouteFilter
+type RouteFilterListResult = original.RouteFilterListResult
+type RouteFilterListResultIterator = original.RouteFilterListResultIterator
+type RouteFilterListResultPage = original.RouteFilterListResultPage
+type RouteFilterPropertiesFormat = original.RouteFilterPropertiesFormat
+type RouteFilterRule = original.RouteFilterRule
+type RouteFilterRuleListResult = original.RouteFilterRuleListResult
+type RouteFilterRuleListResultIterator = original.RouteFilterRuleListResultIterator
+type RouteFilterRuleListResultPage = original.RouteFilterRuleListResultPage
+type RouteFilterRulePropertiesFormat = original.RouteFilterRulePropertiesFormat
+type RouteFilterRulesClient = original.RouteFilterRulesClient
+type RouteFilterRulesCreateOrUpdateFuture = original.RouteFilterRulesCreateOrUpdateFuture
+type RouteFilterRulesDeleteFuture = original.RouteFilterRulesDeleteFuture
+type RouteFilterRulesUpdateFuture = original.RouteFilterRulesUpdateFuture
+type RouteFiltersClient = original.RouteFiltersClient
+type RouteFiltersCreateOrUpdateFuture = original.RouteFiltersCreateOrUpdateFuture
+type RouteFiltersDeleteFuture = original.RouteFiltersDeleteFuture
+type RouteFiltersUpdateFuture = original.RouteFiltersUpdateFuture
+type RouteListResult = original.RouteListResult
+type RouteListResultIterator = original.RouteListResultIterator
+type RouteListResultPage = original.RouteListResultPage
+type RoutePropertiesFormat = original.RoutePropertiesFormat
+type RouteTable = original.RouteTable
+type RouteTableListResult = original.RouteTableListResult
+type RouteTableListResultIterator = original.RouteTableListResultIterator
+type RouteTableListResultPage = original.RouteTableListResultPage
+type RouteTablePropertiesFormat = original.RouteTablePropertiesFormat
+type RouteTablesClient = original.RouteTablesClient
+type RouteTablesCreateOrUpdateFuture = original.RouteTablesCreateOrUpdateFuture
+type RouteTablesDeleteFuture = original.RouteTablesDeleteFuture
+type RouteTablesUpdateTagsFuture = original.RouteTablesUpdateTagsFuture
+type RoutesClient = original.RoutesClient
+type RoutesCreateOrUpdateFuture = original.RoutesCreateOrUpdateFuture
+type RoutesDeleteFuture = original.RoutesDeleteFuture
+type SecurityGroup = original.SecurityGroup
+type SecurityGroupListResult = original.SecurityGroupListResult
+type SecurityGroupListResultIterator = original.SecurityGroupListResultIterator
+type SecurityGroupListResultPage = original.SecurityGroupListResultPage
+type SecurityGroupNetworkInterface = original.SecurityGroupNetworkInterface
+type SecurityGroupPropertiesFormat = original.SecurityGroupPropertiesFormat
+type SecurityGroupViewParameters = original.SecurityGroupViewParameters
+type SecurityGroupViewResult = original.SecurityGroupViewResult
+type SecurityGroupsClient = original.SecurityGroupsClient
+type SecurityGroupsCreateOrUpdateFuture = original.SecurityGroupsCreateOrUpdateFuture
+type SecurityGroupsDeleteFuture = original.SecurityGroupsDeleteFuture
+type SecurityGroupsUpdateTagsFuture = original.SecurityGroupsUpdateTagsFuture
+type SecurityRule = original.SecurityRule
+type SecurityRuleAssociations = original.SecurityRuleAssociations
+type SecurityRuleListResult = original.SecurityRuleListResult
+type SecurityRuleListResultIterator = original.SecurityRuleListResultIterator
+type SecurityRuleListResultPage = original.SecurityRuleListResultPage
+type SecurityRulePropertiesFormat = original.SecurityRulePropertiesFormat
+type SecurityRulesClient = original.SecurityRulesClient
+type SecurityRulesCreateOrUpdateFuture = original.SecurityRulesCreateOrUpdateFuture
+type SecurityRulesDeleteFuture = original.SecurityRulesDeleteFuture
+type ServiceEndpointPropertiesFormat = original.ServiceEndpointPropertiesFormat
+type String = original.String
+type SubResource = original.SubResource
+type Subnet = original.Subnet
+type SubnetAssociation = original.SubnetAssociation
+type SubnetListResult = original.SubnetListResult
+type SubnetListResultIterator = original.SubnetListResultIterator
+type SubnetListResultPage = original.SubnetListResultPage
+type SubnetPropertiesFormat = original.SubnetPropertiesFormat
+type SubnetsClient = original.SubnetsClient
+type SubnetsCreateOrUpdateFuture = original.SubnetsCreateOrUpdateFuture
+type SubnetsDeleteFuture = original.SubnetsDeleteFuture
+type TagsObject = original.TagsObject
+type Topology = original.Topology
+type TopologyAssociation = original.TopologyAssociation
+type TopologyParameters = original.TopologyParameters
+type TopologyResource = original.TopologyResource
+type TroubleshootingDetails = original.TroubleshootingDetails
+type TroubleshootingParameters = original.TroubleshootingParameters
+type TroubleshootingProperties = original.TroubleshootingProperties
+type TroubleshootingRecommendedActions = original.TroubleshootingRecommendedActions
+type TroubleshootingResult = original.TroubleshootingResult
+type TunnelConnectionHealth = original.TunnelConnectionHealth
+type Usage = original.Usage
+type UsageName = original.UsageName
+type UsagesClient = original.UsagesClient
+type UsagesListResult = original.UsagesListResult
+type UsagesListResultIterator = original.UsagesListResultIterator
+type UsagesListResultPage = original.UsagesListResultPage
+type VerificationIPFlowParameters = original.VerificationIPFlowParameters
+type VerificationIPFlowResult = original.VerificationIPFlowResult
+type VirtualNetwork = original.VirtualNetwork
+type VirtualNetworkConnectionGatewayReference = original.VirtualNetworkConnectionGatewayReference
+type VirtualNetworkGateway = original.VirtualNetworkGateway
+type VirtualNetworkGatewayConnection = original.VirtualNetworkGatewayConnection
+type VirtualNetworkGatewayConnectionListEntity = original.VirtualNetworkGatewayConnectionListEntity
+type VirtualNetworkGatewayConnectionListEntityPropertiesFormat = original.VirtualNetworkGatewayConnectionListEntityPropertiesFormat
+type VirtualNetworkGatewayConnectionListResult = original.VirtualNetworkGatewayConnectionListResult
+type VirtualNetworkGatewayConnectionListResultIterator = original.VirtualNetworkGatewayConnectionListResultIterator
+type VirtualNetworkGatewayConnectionListResultPage = original.VirtualNetworkGatewayConnectionListResultPage
+type VirtualNetworkGatewayConnectionPropertiesFormat = original.VirtualNetworkGatewayConnectionPropertiesFormat
+type VirtualNetworkGatewayConnectionsClient = original.VirtualNetworkGatewayConnectionsClient
+type VirtualNetworkGatewayConnectionsCreateOrUpdateFuture = original.VirtualNetworkGatewayConnectionsCreateOrUpdateFuture
+type VirtualNetworkGatewayConnectionsDeleteFuture = original.VirtualNetworkGatewayConnectionsDeleteFuture
+type VirtualNetworkGatewayConnectionsResetSharedKeyFuture = original.VirtualNetworkGatewayConnectionsResetSharedKeyFuture
+type VirtualNetworkGatewayConnectionsSetSharedKeyFuture = original.VirtualNetworkGatewayConnectionsSetSharedKeyFuture
+type VirtualNetworkGatewayConnectionsUpdateTagsFuture = original.VirtualNetworkGatewayConnectionsUpdateTagsFuture
+type VirtualNetworkGatewayIPConfiguration = original.VirtualNetworkGatewayIPConfiguration
+type VirtualNetworkGatewayIPConfigurationPropertiesFormat = original.VirtualNetworkGatewayIPConfigurationPropertiesFormat
+type VirtualNetworkGatewayListConnectionsResult = original.VirtualNetworkGatewayListConnectionsResult
+type VirtualNetworkGatewayListConnectionsResultIterator = original.VirtualNetworkGatewayListConnectionsResultIterator
+type VirtualNetworkGatewayListConnectionsResultPage = original.VirtualNetworkGatewayListConnectionsResultPage
+type VirtualNetworkGatewayListResult = original.VirtualNetworkGatewayListResult
+type VirtualNetworkGatewayListResultIterator = original.VirtualNetworkGatewayListResultIterator
+type VirtualNetworkGatewayListResultPage = original.VirtualNetworkGatewayListResultPage
+type VirtualNetworkGatewayPropertiesFormat = original.VirtualNetworkGatewayPropertiesFormat
+type VirtualNetworkGatewaySku = original.VirtualNetworkGatewaySku
+type VirtualNetworkGatewaysClient = original.VirtualNetworkGatewaysClient
+type VirtualNetworkGatewaysCreateOrUpdateFuture = original.VirtualNetworkGatewaysCreateOrUpdateFuture
+type VirtualNetworkGatewaysDeleteFuture = original.VirtualNetworkGatewaysDeleteFuture
+type VirtualNetworkGatewaysGenerateVpnProfileFuture = original.VirtualNetworkGatewaysGenerateVpnProfileFuture
+type VirtualNetworkGatewaysGeneratevpnclientpackageFuture = original.VirtualNetworkGatewaysGeneratevpnclientpackageFuture
+type VirtualNetworkGatewaysGetAdvertisedRoutesFuture = original.VirtualNetworkGatewaysGetAdvertisedRoutesFuture
+type VirtualNetworkGatewaysGetBgpPeerStatusFuture = original.VirtualNetworkGatewaysGetBgpPeerStatusFuture
+type VirtualNetworkGatewaysGetLearnedRoutesFuture = original.VirtualNetworkGatewaysGetLearnedRoutesFuture
+type VirtualNetworkGatewaysGetVpnProfilePackageURLFuture = original.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture
+type VirtualNetworkGatewaysResetFuture = original.VirtualNetworkGatewaysResetFuture
+type VirtualNetworkGatewaysUpdateTagsFuture = original.VirtualNetworkGatewaysUpdateTagsFuture
+type VirtualNetworkListResult = original.VirtualNetworkListResult
+type VirtualNetworkListResultIterator = original.VirtualNetworkListResultIterator
+type VirtualNetworkListResultPage = original.VirtualNetworkListResultPage
+type VirtualNetworkListUsageResult = original.VirtualNetworkListUsageResult
+type VirtualNetworkListUsageResultIterator = original.VirtualNetworkListUsageResultIterator
+type VirtualNetworkListUsageResultPage = original.VirtualNetworkListUsageResultPage
+type VirtualNetworkPeering = original.VirtualNetworkPeering
+type VirtualNetworkPeeringListResult = original.VirtualNetworkPeeringListResult
+type VirtualNetworkPeeringListResultIterator = original.VirtualNetworkPeeringListResultIterator
+type VirtualNetworkPeeringListResultPage = original.VirtualNetworkPeeringListResultPage
+type VirtualNetworkPeeringPropertiesFormat = original.VirtualNetworkPeeringPropertiesFormat
+type VirtualNetworkPeeringsClient = original.VirtualNetworkPeeringsClient
+type VirtualNetworkPeeringsCreateOrUpdateFuture = original.VirtualNetworkPeeringsCreateOrUpdateFuture
+type VirtualNetworkPeeringsDeleteFuture = original.VirtualNetworkPeeringsDeleteFuture
+type VirtualNetworkPropertiesFormat = original.VirtualNetworkPropertiesFormat
+type VirtualNetworkUsage = original.VirtualNetworkUsage
+type VirtualNetworkUsageName = original.VirtualNetworkUsageName
+type VirtualNetworksClient = original.VirtualNetworksClient
+type VirtualNetworksCreateOrUpdateFuture = original.VirtualNetworksCreateOrUpdateFuture
+type VirtualNetworksDeleteFuture = original.VirtualNetworksDeleteFuture
+type VirtualNetworksUpdateTagsFuture = original.VirtualNetworksUpdateTagsFuture
+type VpnClientConfiguration = original.VpnClientConfiguration
+type VpnClientParameters = original.VpnClientParameters
+type VpnClientRevokedCertificate = original.VpnClientRevokedCertificate
+type VpnClientRevokedCertificatePropertiesFormat = original.VpnClientRevokedCertificatePropertiesFormat
+type VpnClientRootCertificate = original.VpnClientRootCertificate
+type VpnClientRootCertificatePropertiesFormat = original.VpnClientRootCertificatePropertiesFormat
+type VpnDeviceScriptParameters = original.VpnDeviceScriptParameters
+type Watcher = original.Watcher
+type WatcherListResult = original.WatcherListResult
+type WatcherPropertiesFormat = original.WatcherPropertiesFormat
+type WatchersCheckConnectivityFuture = original.WatchersCheckConnectivityFuture
+type WatchersClient = original.WatchersClient
+type WatchersDeleteFuture = original.WatchersDeleteFuture
+type WatchersGetAzureReachabilityReportFuture = original.WatchersGetAzureReachabilityReportFuture
+type WatchersGetFlowLogStatusFuture = original.WatchersGetFlowLogStatusFuture
+type WatchersGetNextHopFuture = original.WatchersGetNextHopFuture
+type WatchersGetTroubleshootingFuture = original.WatchersGetTroubleshootingFuture
+type WatchersGetTroubleshootingResultFuture = original.WatchersGetTroubleshootingResultFuture
+type WatchersGetVMSecurityRulesFuture = original.WatchersGetVMSecurityRulesFuture
+type WatchersListAvailableProvidersFuture = original.WatchersListAvailableProvidersFuture
+type WatchersSetFlowLogConfigurationFuture = original.WatchersSetFlowLogConfigurationFuture
+type WatchersVerifyIPFlowFuture = original.WatchersVerifyIPFlowFuture
+
+func New(subscriptionID string) BaseClient {
+ return original.New(subscriptionID)
+}
+func NewApplicationGatewayAvailableSslPredefinedPoliciesIterator(page ApplicationGatewayAvailableSslPredefinedPoliciesPage) ApplicationGatewayAvailableSslPredefinedPoliciesIterator {
+ return original.NewApplicationGatewayAvailableSslPredefinedPoliciesIterator(page)
+}
+func NewApplicationGatewayAvailableSslPredefinedPoliciesPage(cur ApplicationGatewayAvailableSslPredefinedPolicies, getNextPage func(context.Context, ApplicationGatewayAvailableSslPredefinedPolicies) (ApplicationGatewayAvailableSslPredefinedPolicies, error)) ApplicationGatewayAvailableSslPredefinedPoliciesPage {
+ return original.NewApplicationGatewayAvailableSslPredefinedPoliciesPage(cur, getNextPage)
+}
+func NewApplicationGatewayListResultIterator(page ApplicationGatewayListResultPage) ApplicationGatewayListResultIterator {
+ return original.NewApplicationGatewayListResultIterator(page)
+}
+func NewApplicationGatewayListResultPage(cur ApplicationGatewayListResult, getNextPage func(context.Context, ApplicationGatewayListResult) (ApplicationGatewayListResult, error)) ApplicationGatewayListResultPage {
+ return original.NewApplicationGatewayListResultPage(cur, getNextPage)
+}
+func NewApplicationGatewaysClient(subscriptionID string) ApplicationGatewaysClient {
+ return original.NewApplicationGatewaysClient(subscriptionID)
+}
+func NewApplicationGatewaysClientWithBaseURI(baseURI string, subscriptionID string) ApplicationGatewaysClient {
+ return original.NewApplicationGatewaysClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewApplicationSecurityGroupListResultIterator(page ApplicationSecurityGroupListResultPage) ApplicationSecurityGroupListResultIterator {
+ return original.NewApplicationSecurityGroupListResultIterator(page)
+}
+func NewApplicationSecurityGroupListResultPage(cur ApplicationSecurityGroupListResult, getNextPage func(context.Context, ApplicationSecurityGroupListResult) (ApplicationSecurityGroupListResult, error)) ApplicationSecurityGroupListResultPage {
+ return original.NewApplicationSecurityGroupListResultPage(cur, getNextPage)
+}
+func NewApplicationSecurityGroupsClient(subscriptionID string) ApplicationSecurityGroupsClient {
+ return original.NewApplicationSecurityGroupsClient(subscriptionID)
+}
+func NewApplicationSecurityGroupsClientWithBaseURI(baseURI string, subscriptionID string) ApplicationSecurityGroupsClient {
+ return original.NewApplicationSecurityGroupsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewAuthorizationListResultIterator(page AuthorizationListResultPage) AuthorizationListResultIterator {
+ return original.NewAuthorizationListResultIterator(page)
+}
+func NewAuthorizationListResultPage(cur AuthorizationListResult, getNextPage func(context.Context, AuthorizationListResult) (AuthorizationListResult, error)) AuthorizationListResultPage {
+ return original.NewAuthorizationListResultPage(cur, getNextPage)
+}
+func NewAvailableEndpointServicesClient(subscriptionID string) AvailableEndpointServicesClient {
+ return original.NewAvailableEndpointServicesClient(subscriptionID)
+}
+func NewAvailableEndpointServicesClientWithBaseURI(baseURI string, subscriptionID string) AvailableEndpointServicesClient {
+ return original.NewAvailableEndpointServicesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewBgpServiceCommunitiesClient(subscriptionID string) BgpServiceCommunitiesClient {
+ return original.NewBgpServiceCommunitiesClient(subscriptionID)
+}
+func NewBgpServiceCommunitiesClientWithBaseURI(baseURI string, subscriptionID string) BgpServiceCommunitiesClient {
+ return original.NewBgpServiceCommunitiesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewBgpServiceCommunityListResultIterator(page BgpServiceCommunityListResultPage) BgpServiceCommunityListResultIterator {
+ return original.NewBgpServiceCommunityListResultIterator(page)
+}
+func NewBgpServiceCommunityListResultPage(cur BgpServiceCommunityListResult, getNextPage func(context.Context, BgpServiceCommunityListResult) (BgpServiceCommunityListResult, error)) BgpServiceCommunityListResultPage {
+ return original.NewBgpServiceCommunityListResultPage(cur, getNextPage)
+}
+func NewConnectionMonitorsClient(subscriptionID string) ConnectionMonitorsClient {
+ return original.NewConnectionMonitorsClient(subscriptionID)
+}
+func NewConnectionMonitorsClientWithBaseURI(baseURI string, subscriptionID string) ConnectionMonitorsClient {
+ return original.NewConnectionMonitorsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewDefaultSecurityRulesClient(subscriptionID string) DefaultSecurityRulesClient {
+ return original.NewDefaultSecurityRulesClient(subscriptionID)
+}
+func NewDefaultSecurityRulesClientWithBaseURI(baseURI string, subscriptionID string) DefaultSecurityRulesClient {
+ return original.NewDefaultSecurityRulesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewEndpointServicesListResultIterator(page EndpointServicesListResultPage) EndpointServicesListResultIterator {
+ return original.NewEndpointServicesListResultIterator(page)
+}
+func NewEndpointServicesListResultPage(cur EndpointServicesListResult, getNextPage func(context.Context, EndpointServicesListResult) (EndpointServicesListResult, error)) EndpointServicesListResultPage {
+ return original.NewEndpointServicesListResultPage(cur, getNextPage)
+}
+func NewExpressRouteCircuitAuthorizationsClient(subscriptionID string) ExpressRouteCircuitAuthorizationsClient {
+ return original.NewExpressRouteCircuitAuthorizationsClient(subscriptionID)
+}
+func NewExpressRouteCircuitAuthorizationsClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteCircuitAuthorizationsClient {
+ return original.NewExpressRouteCircuitAuthorizationsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewExpressRouteCircuitListResultIterator(page ExpressRouteCircuitListResultPage) ExpressRouteCircuitListResultIterator {
+ return original.NewExpressRouteCircuitListResultIterator(page)
+}
+func NewExpressRouteCircuitListResultPage(cur ExpressRouteCircuitListResult, getNextPage func(context.Context, ExpressRouteCircuitListResult) (ExpressRouteCircuitListResult, error)) ExpressRouteCircuitListResultPage {
+ return original.NewExpressRouteCircuitListResultPage(cur, getNextPage)
+}
+func NewExpressRouteCircuitPeeringListResultIterator(page ExpressRouteCircuitPeeringListResultPage) ExpressRouteCircuitPeeringListResultIterator {
+ return original.NewExpressRouteCircuitPeeringListResultIterator(page)
+}
+func NewExpressRouteCircuitPeeringListResultPage(cur ExpressRouteCircuitPeeringListResult, getNextPage func(context.Context, ExpressRouteCircuitPeeringListResult) (ExpressRouteCircuitPeeringListResult, error)) ExpressRouteCircuitPeeringListResultPage {
+ return original.NewExpressRouteCircuitPeeringListResultPage(cur, getNextPage)
+}
+func NewExpressRouteCircuitPeeringsClient(subscriptionID string) ExpressRouteCircuitPeeringsClient {
+ return original.NewExpressRouteCircuitPeeringsClient(subscriptionID)
+}
+func NewExpressRouteCircuitPeeringsClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteCircuitPeeringsClient {
+ return original.NewExpressRouteCircuitPeeringsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewExpressRouteCircuitsClient(subscriptionID string) ExpressRouteCircuitsClient {
+ return original.NewExpressRouteCircuitsClient(subscriptionID)
+}
+func NewExpressRouteCircuitsClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteCircuitsClient {
+ return original.NewExpressRouteCircuitsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewExpressRouteServiceProviderListResultIterator(page ExpressRouteServiceProviderListResultPage) ExpressRouteServiceProviderListResultIterator {
+ return original.NewExpressRouteServiceProviderListResultIterator(page)
+}
+func NewExpressRouteServiceProviderListResultPage(cur ExpressRouteServiceProviderListResult, getNextPage func(context.Context, ExpressRouteServiceProviderListResult) (ExpressRouteServiceProviderListResult, error)) ExpressRouteServiceProviderListResultPage {
+ return original.NewExpressRouteServiceProviderListResultPage(cur, getNextPage)
+}
+func NewExpressRouteServiceProvidersClient(subscriptionID string) ExpressRouteServiceProvidersClient {
+ return original.NewExpressRouteServiceProvidersClient(subscriptionID)
+}
+func NewExpressRouteServiceProvidersClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteServiceProvidersClient {
+ return original.NewExpressRouteServiceProvidersClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewInboundNatRuleListResultIterator(page InboundNatRuleListResultPage) InboundNatRuleListResultIterator {
+ return original.NewInboundNatRuleListResultIterator(page)
+}
+func NewInboundNatRuleListResultPage(cur InboundNatRuleListResult, getNextPage func(context.Context, InboundNatRuleListResult) (InboundNatRuleListResult, error)) InboundNatRuleListResultPage {
+ return original.NewInboundNatRuleListResultPage(cur, getNextPage)
+}
+func NewInboundNatRulesClient(subscriptionID string) InboundNatRulesClient {
+ return original.NewInboundNatRulesClient(subscriptionID)
+}
+func NewInboundNatRulesClientWithBaseURI(baseURI string, subscriptionID string) InboundNatRulesClient {
+ return original.NewInboundNatRulesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewInterfaceIPConfigurationListResultIterator(page InterfaceIPConfigurationListResultPage) InterfaceIPConfigurationListResultIterator {
+ return original.NewInterfaceIPConfigurationListResultIterator(page)
+}
+func NewInterfaceIPConfigurationListResultPage(cur InterfaceIPConfigurationListResult, getNextPage func(context.Context, InterfaceIPConfigurationListResult) (InterfaceIPConfigurationListResult, error)) InterfaceIPConfigurationListResultPage {
+ return original.NewInterfaceIPConfigurationListResultPage(cur, getNextPage)
+}
+func NewInterfaceIPConfigurationsClient(subscriptionID string) InterfaceIPConfigurationsClient {
+ return original.NewInterfaceIPConfigurationsClient(subscriptionID)
+}
+func NewInterfaceIPConfigurationsClientWithBaseURI(baseURI string, subscriptionID string) InterfaceIPConfigurationsClient {
+ return original.NewInterfaceIPConfigurationsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewInterfaceListResultIterator(page InterfaceListResultPage) InterfaceListResultIterator {
+ return original.NewInterfaceListResultIterator(page)
+}
+func NewInterfaceListResultPage(cur InterfaceListResult, getNextPage func(context.Context, InterfaceListResult) (InterfaceListResult, error)) InterfaceListResultPage {
+ return original.NewInterfaceListResultPage(cur, getNextPage)
+}
+func NewInterfaceLoadBalancerListResultIterator(page InterfaceLoadBalancerListResultPage) InterfaceLoadBalancerListResultIterator {
+ return original.NewInterfaceLoadBalancerListResultIterator(page)
+}
+func NewInterfaceLoadBalancerListResultPage(cur InterfaceLoadBalancerListResult, getNextPage func(context.Context, InterfaceLoadBalancerListResult) (InterfaceLoadBalancerListResult, error)) InterfaceLoadBalancerListResultPage {
+ return original.NewInterfaceLoadBalancerListResultPage(cur, getNextPage)
+}
+func NewInterfaceLoadBalancersClient(subscriptionID string) InterfaceLoadBalancersClient {
+ return original.NewInterfaceLoadBalancersClient(subscriptionID)
+}
+func NewInterfaceLoadBalancersClientWithBaseURI(baseURI string, subscriptionID string) InterfaceLoadBalancersClient {
+ return original.NewInterfaceLoadBalancersClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewInterfacesClient(subscriptionID string) InterfacesClient {
+ return original.NewInterfacesClient(subscriptionID)
+}
+func NewInterfacesClientWithBaseURI(baseURI string, subscriptionID string) InterfacesClient {
+ return original.NewInterfacesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewLoadBalancerBackendAddressPoolListResultIterator(page LoadBalancerBackendAddressPoolListResultPage) LoadBalancerBackendAddressPoolListResultIterator {
+ return original.NewLoadBalancerBackendAddressPoolListResultIterator(page)
+}
+func NewLoadBalancerBackendAddressPoolListResultPage(cur LoadBalancerBackendAddressPoolListResult, getNextPage func(context.Context, LoadBalancerBackendAddressPoolListResult) (LoadBalancerBackendAddressPoolListResult, error)) LoadBalancerBackendAddressPoolListResultPage {
+ return original.NewLoadBalancerBackendAddressPoolListResultPage(cur, getNextPage)
+}
+func NewLoadBalancerBackendAddressPoolsClient(subscriptionID string) LoadBalancerBackendAddressPoolsClient {
+ return original.NewLoadBalancerBackendAddressPoolsClient(subscriptionID)
+}
+func NewLoadBalancerBackendAddressPoolsClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerBackendAddressPoolsClient {
+ return original.NewLoadBalancerBackendAddressPoolsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewLoadBalancerFrontendIPConfigurationListResultIterator(page LoadBalancerFrontendIPConfigurationListResultPage) LoadBalancerFrontendIPConfigurationListResultIterator {
+ return original.NewLoadBalancerFrontendIPConfigurationListResultIterator(page)
+}
+func NewLoadBalancerFrontendIPConfigurationListResultPage(cur LoadBalancerFrontendIPConfigurationListResult, getNextPage func(context.Context, LoadBalancerFrontendIPConfigurationListResult) (LoadBalancerFrontendIPConfigurationListResult, error)) LoadBalancerFrontendIPConfigurationListResultPage {
+ return original.NewLoadBalancerFrontendIPConfigurationListResultPage(cur, getNextPage)
+}
+func NewLoadBalancerFrontendIPConfigurationsClient(subscriptionID string) LoadBalancerFrontendIPConfigurationsClient {
+ return original.NewLoadBalancerFrontendIPConfigurationsClient(subscriptionID)
+}
+func NewLoadBalancerFrontendIPConfigurationsClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerFrontendIPConfigurationsClient {
+ return original.NewLoadBalancerFrontendIPConfigurationsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewLoadBalancerListResultIterator(page LoadBalancerListResultPage) LoadBalancerListResultIterator {
+ return original.NewLoadBalancerListResultIterator(page)
+}
+func NewLoadBalancerListResultPage(cur LoadBalancerListResult, getNextPage func(context.Context, LoadBalancerListResult) (LoadBalancerListResult, error)) LoadBalancerListResultPage {
+ return original.NewLoadBalancerListResultPage(cur, getNextPage)
+}
+func NewLoadBalancerLoadBalancingRuleListResultIterator(page LoadBalancerLoadBalancingRuleListResultPage) LoadBalancerLoadBalancingRuleListResultIterator {
+ return original.NewLoadBalancerLoadBalancingRuleListResultIterator(page)
+}
+func NewLoadBalancerLoadBalancingRuleListResultPage(cur LoadBalancerLoadBalancingRuleListResult, getNextPage func(context.Context, LoadBalancerLoadBalancingRuleListResult) (LoadBalancerLoadBalancingRuleListResult, error)) LoadBalancerLoadBalancingRuleListResultPage {
+ return original.NewLoadBalancerLoadBalancingRuleListResultPage(cur, getNextPage)
+}
+func NewLoadBalancerLoadBalancingRulesClient(subscriptionID string) LoadBalancerLoadBalancingRulesClient {
+ return original.NewLoadBalancerLoadBalancingRulesClient(subscriptionID)
+}
+func NewLoadBalancerLoadBalancingRulesClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerLoadBalancingRulesClient {
+ return original.NewLoadBalancerLoadBalancingRulesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewLoadBalancerNetworkInterfacesClient(subscriptionID string) LoadBalancerNetworkInterfacesClient {
+ return original.NewLoadBalancerNetworkInterfacesClient(subscriptionID)
+}
+func NewLoadBalancerNetworkInterfacesClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerNetworkInterfacesClient {
+ return original.NewLoadBalancerNetworkInterfacesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewLoadBalancerProbeListResultIterator(page LoadBalancerProbeListResultPage) LoadBalancerProbeListResultIterator {
+ return original.NewLoadBalancerProbeListResultIterator(page)
+}
+func NewLoadBalancerProbeListResultPage(cur LoadBalancerProbeListResult, getNextPage func(context.Context, LoadBalancerProbeListResult) (LoadBalancerProbeListResult, error)) LoadBalancerProbeListResultPage {
+ return original.NewLoadBalancerProbeListResultPage(cur, getNextPage)
+}
+func NewLoadBalancerProbesClient(subscriptionID string) LoadBalancerProbesClient {
+ return original.NewLoadBalancerProbesClient(subscriptionID)
+}
+func NewLoadBalancerProbesClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerProbesClient {
+ return original.NewLoadBalancerProbesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewLoadBalancersClient(subscriptionID string) LoadBalancersClient {
+ return original.NewLoadBalancersClient(subscriptionID)
+}
+func NewLoadBalancersClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancersClient {
+ return original.NewLoadBalancersClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewLocalNetworkGatewayListResultIterator(page LocalNetworkGatewayListResultPage) LocalNetworkGatewayListResultIterator {
+ return original.NewLocalNetworkGatewayListResultIterator(page)
+}
+func NewLocalNetworkGatewayListResultPage(cur LocalNetworkGatewayListResult, getNextPage func(context.Context, LocalNetworkGatewayListResult) (LocalNetworkGatewayListResult, error)) LocalNetworkGatewayListResultPage {
+ return original.NewLocalNetworkGatewayListResultPage(cur, getNextPage)
+}
+func NewLocalNetworkGatewaysClient(subscriptionID string) LocalNetworkGatewaysClient {
+ return original.NewLocalNetworkGatewaysClient(subscriptionID)
+}
+func NewLocalNetworkGatewaysClientWithBaseURI(baseURI string, subscriptionID string) LocalNetworkGatewaysClient {
+ return original.NewLocalNetworkGatewaysClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewOperationListResultIterator(page OperationListResultPage) OperationListResultIterator {
+ return original.NewOperationListResultIterator(page)
+}
+func NewOperationListResultPage(cur OperationListResult, getNextPage func(context.Context, OperationListResult) (OperationListResult, error)) OperationListResultPage {
+ return original.NewOperationListResultPage(cur, getNextPage)
+}
+func NewOperationsClient(subscriptionID string) OperationsClient {
+ return original.NewOperationsClient(subscriptionID)
+}
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+ return original.NewOperationsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewPacketCapturesClient(subscriptionID string) PacketCapturesClient {
+ return original.NewPacketCapturesClient(subscriptionID)
+}
+func NewPacketCapturesClientWithBaseURI(baseURI string, subscriptionID string) PacketCapturesClient {
+ return original.NewPacketCapturesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewPublicIPAddressListResultIterator(page PublicIPAddressListResultPage) PublicIPAddressListResultIterator {
+ return original.NewPublicIPAddressListResultIterator(page)
+}
+func NewPublicIPAddressListResultPage(cur PublicIPAddressListResult, getNextPage func(context.Context, PublicIPAddressListResult) (PublicIPAddressListResult, error)) PublicIPAddressListResultPage {
+ return original.NewPublicIPAddressListResultPage(cur, getNextPage)
+}
+func NewPublicIPAddressesClient(subscriptionID string) PublicIPAddressesClient {
+ return original.NewPublicIPAddressesClient(subscriptionID)
+}
+func NewPublicIPAddressesClientWithBaseURI(baseURI string, subscriptionID string) PublicIPAddressesClient {
+ return original.NewPublicIPAddressesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewRouteFilterListResultIterator(page RouteFilterListResultPage) RouteFilterListResultIterator {
+ return original.NewRouteFilterListResultIterator(page)
+}
+func NewRouteFilterListResultPage(cur RouteFilterListResult, getNextPage func(context.Context, RouteFilterListResult) (RouteFilterListResult, error)) RouteFilterListResultPage {
+ return original.NewRouteFilterListResultPage(cur, getNextPage)
+}
+func NewRouteFilterRuleListResultIterator(page RouteFilterRuleListResultPage) RouteFilterRuleListResultIterator {
+ return original.NewRouteFilterRuleListResultIterator(page)
+}
+func NewRouteFilterRuleListResultPage(cur RouteFilterRuleListResult, getNextPage func(context.Context, RouteFilterRuleListResult) (RouteFilterRuleListResult, error)) RouteFilterRuleListResultPage {
+ return original.NewRouteFilterRuleListResultPage(cur, getNextPage)
+}
+func NewRouteFilterRulesClient(subscriptionID string) RouteFilterRulesClient {
+ return original.NewRouteFilterRulesClient(subscriptionID)
+}
+func NewRouteFilterRulesClientWithBaseURI(baseURI string, subscriptionID string) RouteFilterRulesClient {
+ return original.NewRouteFilterRulesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewRouteFiltersClient(subscriptionID string) RouteFiltersClient {
+ return original.NewRouteFiltersClient(subscriptionID)
+}
+func NewRouteFiltersClientWithBaseURI(baseURI string, subscriptionID string) RouteFiltersClient {
+ return original.NewRouteFiltersClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewRouteListResultIterator(page RouteListResultPage) RouteListResultIterator {
+ return original.NewRouteListResultIterator(page)
+}
+func NewRouteListResultPage(cur RouteListResult, getNextPage func(context.Context, RouteListResult) (RouteListResult, error)) RouteListResultPage {
+ return original.NewRouteListResultPage(cur, getNextPage)
+}
+func NewRouteTableListResultIterator(page RouteTableListResultPage) RouteTableListResultIterator {
+ return original.NewRouteTableListResultIterator(page)
+}
+func NewRouteTableListResultPage(cur RouteTableListResult, getNextPage func(context.Context, RouteTableListResult) (RouteTableListResult, error)) RouteTableListResultPage {
+ return original.NewRouteTableListResultPage(cur, getNextPage)
+}
+func NewRouteTablesClient(subscriptionID string) RouteTablesClient {
+ return original.NewRouteTablesClient(subscriptionID)
+}
+func NewRouteTablesClientWithBaseURI(baseURI string, subscriptionID string) RouteTablesClient {
+ return original.NewRouteTablesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewRoutesClient(subscriptionID string) RoutesClient {
+ return original.NewRoutesClient(subscriptionID)
+}
+func NewRoutesClientWithBaseURI(baseURI string, subscriptionID string) RoutesClient {
+ return original.NewRoutesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewSecurityGroupListResultIterator(page SecurityGroupListResultPage) SecurityGroupListResultIterator {
+ return original.NewSecurityGroupListResultIterator(page)
+}
+func NewSecurityGroupListResultPage(cur SecurityGroupListResult, getNextPage func(context.Context, SecurityGroupListResult) (SecurityGroupListResult, error)) SecurityGroupListResultPage {
+ return original.NewSecurityGroupListResultPage(cur, getNextPage)
+}
+func NewSecurityGroupsClient(subscriptionID string) SecurityGroupsClient {
+ return original.NewSecurityGroupsClient(subscriptionID)
+}
+func NewSecurityGroupsClientWithBaseURI(baseURI string, subscriptionID string) SecurityGroupsClient {
+ return original.NewSecurityGroupsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewSecurityRuleListResultIterator(page SecurityRuleListResultPage) SecurityRuleListResultIterator {
+ return original.NewSecurityRuleListResultIterator(page)
+}
+func NewSecurityRuleListResultPage(cur SecurityRuleListResult, getNextPage func(context.Context, SecurityRuleListResult) (SecurityRuleListResult, error)) SecurityRuleListResultPage {
+ return original.NewSecurityRuleListResultPage(cur, getNextPage)
+}
+func NewSecurityRulesClient(subscriptionID string) SecurityRulesClient {
+ return original.NewSecurityRulesClient(subscriptionID)
+}
+func NewSecurityRulesClientWithBaseURI(baseURI string, subscriptionID string) SecurityRulesClient {
+ return original.NewSecurityRulesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewSubnetListResultIterator(page SubnetListResultPage) SubnetListResultIterator {
+ return original.NewSubnetListResultIterator(page)
+}
+func NewSubnetListResultPage(cur SubnetListResult, getNextPage func(context.Context, SubnetListResult) (SubnetListResult, error)) SubnetListResultPage {
+ return original.NewSubnetListResultPage(cur, getNextPage)
+}
+func NewSubnetsClient(subscriptionID string) SubnetsClient {
+ return original.NewSubnetsClient(subscriptionID)
+}
+func NewSubnetsClientWithBaseURI(baseURI string, subscriptionID string) SubnetsClient {
+ return original.NewSubnetsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewUsagesClient(subscriptionID string) UsagesClient {
+ return original.NewUsagesClient(subscriptionID)
+}
+func NewUsagesClientWithBaseURI(baseURI string, subscriptionID string) UsagesClient {
+ return original.NewUsagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewUsagesListResultIterator(page UsagesListResultPage) UsagesListResultIterator {
+ return original.NewUsagesListResultIterator(page)
+}
+func NewUsagesListResultPage(cur UsagesListResult, getNextPage func(context.Context, UsagesListResult) (UsagesListResult, error)) UsagesListResultPage {
+ return original.NewUsagesListResultPage(cur, getNextPage)
+}
+func NewVirtualNetworkGatewayConnectionListResultIterator(page VirtualNetworkGatewayConnectionListResultPage) VirtualNetworkGatewayConnectionListResultIterator {
+ return original.NewVirtualNetworkGatewayConnectionListResultIterator(page)
+}
+func NewVirtualNetworkGatewayConnectionListResultPage(cur VirtualNetworkGatewayConnectionListResult, getNextPage func(context.Context, VirtualNetworkGatewayConnectionListResult) (VirtualNetworkGatewayConnectionListResult, error)) VirtualNetworkGatewayConnectionListResultPage {
+ return original.NewVirtualNetworkGatewayConnectionListResultPage(cur, getNextPage)
+}
+func NewVirtualNetworkGatewayConnectionsClient(subscriptionID string) VirtualNetworkGatewayConnectionsClient {
+ return original.NewVirtualNetworkGatewayConnectionsClient(subscriptionID)
+}
+func NewVirtualNetworkGatewayConnectionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworkGatewayConnectionsClient {
+ return original.NewVirtualNetworkGatewayConnectionsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualNetworkGatewayListConnectionsResultIterator(page VirtualNetworkGatewayListConnectionsResultPage) VirtualNetworkGatewayListConnectionsResultIterator {
+ return original.NewVirtualNetworkGatewayListConnectionsResultIterator(page)
+}
+func NewVirtualNetworkGatewayListConnectionsResultPage(cur VirtualNetworkGatewayListConnectionsResult, getNextPage func(context.Context, VirtualNetworkGatewayListConnectionsResult) (VirtualNetworkGatewayListConnectionsResult, error)) VirtualNetworkGatewayListConnectionsResultPage {
+ return original.NewVirtualNetworkGatewayListConnectionsResultPage(cur, getNextPage)
+}
+func NewVirtualNetworkGatewayListResultIterator(page VirtualNetworkGatewayListResultPage) VirtualNetworkGatewayListResultIterator {
+ return original.NewVirtualNetworkGatewayListResultIterator(page)
+}
+func NewVirtualNetworkGatewayListResultPage(cur VirtualNetworkGatewayListResult, getNextPage func(context.Context, VirtualNetworkGatewayListResult) (VirtualNetworkGatewayListResult, error)) VirtualNetworkGatewayListResultPage {
+ return original.NewVirtualNetworkGatewayListResultPage(cur, getNextPage)
+}
+func NewVirtualNetworkGatewaysClient(subscriptionID string) VirtualNetworkGatewaysClient {
+ return original.NewVirtualNetworkGatewaysClient(subscriptionID)
+}
+func NewVirtualNetworkGatewaysClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworkGatewaysClient {
+ return original.NewVirtualNetworkGatewaysClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualNetworkListResultIterator(page VirtualNetworkListResultPage) VirtualNetworkListResultIterator {
+ return original.NewVirtualNetworkListResultIterator(page)
+}
+func NewVirtualNetworkListResultPage(cur VirtualNetworkListResult, getNextPage func(context.Context, VirtualNetworkListResult) (VirtualNetworkListResult, error)) VirtualNetworkListResultPage {
+ return original.NewVirtualNetworkListResultPage(cur, getNextPage)
+}
+func NewVirtualNetworkListUsageResultIterator(page VirtualNetworkListUsageResultPage) VirtualNetworkListUsageResultIterator {
+ return original.NewVirtualNetworkListUsageResultIterator(page)
+}
+func NewVirtualNetworkListUsageResultPage(cur VirtualNetworkListUsageResult, getNextPage func(context.Context, VirtualNetworkListUsageResult) (VirtualNetworkListUsageResult, error)) VirtualNetworkListUsageResultPage {
+ return original.NewVirtualNetworkListUsageResultPage(cur, getNextPage)
+}
+func NewVirtualNetworkPeeringListResultIterator(page VirtualNetworkPeeringListResultPage) VirtualNetworkPeeringListResultIterator {
+ return original.NewVirtualNetworkPeeringListResultIterator(page)
+}
+func NewVirtualNetworkPeeringListResultPage(cur VirtualNetworkPeeringListResult, getNextPage func(context.Context, VirtualNetworkPeeringListResult) (VirtualNetworkPeeringListResult, error)) VirtualNetworkPeeringListResultPage {
+ return original.NewVirtualNetworkPeeringListResultPage(cur, getNextPage)
+}
+func NewVirtualNetworkPeeringsClient(subscriptionID string) VirtualNetworkPeeringsClient {
+ return original.NewVirtualNetworkPeeringsClient(subscriptionID)
+}
+func NewVirtualNetworkPeeringsClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworkPeeringsClient {
+ return original.NewVirtualNetworkPeeringsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualNetworksClient(subscriptionID string) VirtualNetworksClient {
+ return original.NewVirtualNetworksClient(subscriptionID)
+}
+func NewVirtualNetworksClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworksClient {
+ return original.NewVirtualNetworksClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewWatchersClient(subscriptionID string) WatchersClient {
+ return original.NewWatchersClient(subscriptionID)
+}
+func NewWatchersClientWithBaseURI(baseURI string, subscriptionID string) WatchersClient {
+ return original.NewWatchersClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+ return original.NewWithBaseURI(baseURI, subscriptionID)
+}
+func PossibleAccessValues() []Access {
+ return original.PossibleAccessValues()
+}
+func PossibleApplicationGatewayBackendHealthServerHealthValues() []ApplicationGatewayBackendHealthServerHealth {
+ return original.PossibleApplicationGatewayBackendHealthServerHealthValues()
+}
+func PossibleApplicationGatewayCookieBasedAffinityValues() []ApplicationGatewayCookieBasedAffinity {
+ return original.PossibleApplicationGatewayCookieBasedAffinityValues()
+}
+func PossibleApplicationGatewayFirewallModeValues() []ApplicationGatewayFirewallMode {
+ return original.PossibleApplicationGatewayFirewallModeValues()
+}
+func PossibleApplicationGatewayOperationalStateValues() []ApplicationGatewayOperationalState {
+ return original.PossibleApplicationGatewayOperationalStateValues()
+}
+func PossibleApplicationGatewayProtocolValues() []ApplicationGatewayProtocol {
+ return original.PossibleApplicationGatewayProtocolValues()
+}
+func PossibleApplicationGatewayRedirectTypeValues() []ApplicationGatewayRedirectType {
+ return original.PossibleApplicationGatewayRedirectTypeValues()
+}
+func PossibleApplicationGatewayRequestRoutingRuleTypeValues() []ApplicationGatewayRequestRoutingRuleType {
+ return original.PossibleApplicationGatewayRequestRoutingRuleTypeValues()
+}
+func PossibleApplicationGatewaySkuNameValues() []ApplicationGatewaySkuName {
+ return original.PossibleApplicationGatewaySkuNameValues()
+}
+func PossibleApplicationGatewaySslCipherSuiteValues() []ApplicationGatewaySslCipherSuite {
+ return original.PossibleApplicationGatewaySslCipherSuiteValues()
+}
+func PossibleApplicationGatewaySslPolicyNameValues() []ApplicationGatewaySslPolicyName {
+ return original.PossibleApplicationGatewaySslPolicyNameValues()
+}
+func PossibleApplicationGatewaySslPolicyTypeValues() []ApplicationGatewaySslPolicyType {
+ return original.PossibleApplicationGatewaySslPolicyTypeValues()
+}
+func PossibleApplicationGatewaySslProtocolValues() []ApplicationGatewaySslProtocol {
+ return original.PossibleApplicationGatewaySslProtocolValues()
+}
+func PossibleApplicationGatewayTierValues() []ApplicationGatewayTier {
+ return original.PossibleApplicationGatewayTierValues()
+}
+func PossibleAssociationTypeValues() []AssociationType {
+ return original.PossibleAssociationTypeValues()
+}
+func PossibleAuthenticationMethodValues() []AuthenticationMethod {
+ return original.PossibleAuthenticationMethodValues()
+}
+func PossibleAuthorizationUseStatusValues() []AuthorizationUseStatus {
+ return original.PossibleAuthorizationUseStatusValues()
+}
+func PossibleBgpPeerStateValues() []BgpPeerState {
+ return original.PossibleBgpPeerStateValues()
+}
+func PossibleConnectionStateValues() []ConnectionState {
+ return original.PossibleConnectionStateValues()
+}
+func PossibleConnectionStatusValues() []ConnectionStatus {
+ return original.PossibleConnectionStatusValues()
+}
+func PossibleDhGroupValues() []DhGroup {
+ return original.PossibleDhGroupValues()
+}
+func PossibleDirectionValues() []Direction {
+ return original.PossibleDirectionValues()
+}
+func PossibleEffectiveRouteSourceValues() []EffectiveRouteSource {
+ return original.PossibleEffectiveRouteSourceValues()
+}
+func PossibleEffectiveRouteStateValues() []EffectiveRouteState {
+ return original.PossibleEffectiveRouteStateValues()
+}
+func PossibleEffectiveSecurityRuleProtocolValues() []EffectiveSecurityRuleProtocol {
+ return original.PossibleEffectiveSecurityRuleProtocolValues()
+}
+func PossibleEvaluationStateValues() []EvaluationState {
+ return original.PossibleEvaluationStateValues()
+}
+func PossibleExpressRouteCircuitPeeringAdvertisedPublicPrefixStateValues() []ExpressRouteCircuitPeeringAdvertisedPublicPrefixState {
+ return original.PossibleExpressRouteCircuitPeeringAdvertisedPublicPrefixStateValues()
+}
+func PossibleExpressRouteCircuitPeeringStateValues() []ExpressRouteCircuitPeeringState {
+ return original.PossibleExpressRouteCircuitPeeringStateValues()
+}
+func PossibleExpressRouteCircuitPeeringTypeValues() []ExpressRouteCircuitPeeringType {
+ return original.PossibleExpressRouteCircuitPeeringTypeValues()
+}
+func PossibleExpressRouteCircuitSkuFamilyValues() []ExpressRouteCircuitSkuFamily {
+ return original.PossibleExpressRouteCircuitSkuFamilyValues()
+}
+func PossibleExpressRouteCircuitSkuTierValues() []ExpressRouteCircuitSkuTier {
+ return original.PossibleExpressRouteCircuitSkuTierValues()
+}
+func PossibleIPAllocationMethodValues() []IPAllocationMethod {
+ return original.PossibleIPAllocationMethodValues()
+}
+func PossibleIPVersionValues() []IPVersion {
+ return original.PossibleIPVersionValues()
+}
+func PossibleIkeEncryptionValues() []IkeEncryption {
+ return original.PossibleIkeEncryptionValues()
+}
+func PossibleIkeIntegrityValues() []IkeIntegrity {
+ return original.PossibleIkeIntegrityValues()
+}
+func PossibleIpsecEncryptionValues() []IpsecEncryption {
+ return original.PossibleIpsecEncryptionValues()
+}
+func PossibleIpsecIntegrityValues() []IpsecIntegrity {
+ return original.PossibleIpsecIntegrityValues()
+}
+func PossibleIssueTypeValues() []IssueType {
+ return original.PossibleIssueTypeValues()
+}
+func PossibleLoadBalancerSkuNameValues() []LoadBalancerSkuName {
+ return original.PossibleLoadBalancerSkuNameValues()
+}
+func PossibleLoadDistributionValues() []LoadDistribution {
+ return original.PossibleLoadDistributionValues()
+}
+func PossibleNextHopTypeValues() []NextHopType {
+ return original.PossibleNextHopTypeValues()
+}
+func PossibleOperationStatusValues() []OperationStatus {
+ return original.PossibleOperationStatusValues()
+}
+func PossibleOriginValues() []Origin {
+ return original.PossibleOriginValues()
+}
+func PossiblePcErrorValues() []PcError {
+ return original.PossiblePcErrorValues()
+}
+func PossiblePcProtocolValues() []PcProtocol {
+ return original.PossiblePcProtocolValues()
+}
+func PossiblePcStatusValues() []PcStatus {
+ return original.PossiblePcStatusValues()
+}
+func PossiblePfsGroupValues() []PfsGroup {
+ return original.PossiblePfsGroupValues()
+}
+func PossibleProbeProtocolValues() []ProbeProtocol {
+ return original.PossibleProbeProtocolValues()
+}
+func PossibleProcessorArchitectureValues() []ProcessorArchitecture {
+ return original.PossibleProcessorArchitectureValues()
+}
+func PossibleProtocolValues() []Protocol {
+ return original.PossibleProtocolValues()
+}
+func PossibleProvisioningStateValues() []ProvisioningState {
+ return original.PossibleProvisioningStateValues()
+}
+func PossiblePublicIPAddressSkuNameValues() []PublicIPAddressSkuName {
+ return original.PossiblePublicIPAddressSkuNameValues()
+}
+func PossibleRouteNextHopTypeValues() []RouteNextHopType {
+ return original.PossibleRouteNextHopTypeValues()
+}
+func PossibleSecurityRuleAccessValues() []SecurityRuleAccess {
+ return original.PossibleSecurityRuleAccessValues()
+}
+func PossibleSecurityRuleDirectionValues() []SecurityRuleDirection {
+ return original.PossibleSecurityRuleDirectionValues()
+}
+func PossibleSecurityRuleProtocolValues() []SecurityRuleProtocol {
+ return original.PossibleSecurityRuleProtocolValues()
+}
+func PossibleServiceProviderProvisioningStateValues() []ServiceProviderProvisioningState {
+ return original.PossibleServiceProviderProvisioningStateValues()
+}
+func PossibleSeverityValues() []Severity {
+ return original.PossibleSeverityValues()
+}
+func PossibleTransportProtocolValues() []TransportProtocol {
+ return original.PossibleTransportProtocolValues()
+}
+func PossibleVirtualNetworkGatewayConnectionStatusValues() []VirtualNetworkGatewayConnectionStatus {
+ return original.PossibleVirtualNetworkGatewayConnectionStatusValues()
+}
+func PossibleVirtualNetworkGatewayConnectionTypeValues() []VirtualNetworkGatewayConnectionType {
+ return original.PossibleVirtualNetworkGatewayConnectionTypeValues()
+}
+func PossibleVirtualNetworkGatewaySkuNameValues() []VirtualNetworkGatewaySkuName {
+ return original.PossibleVirtualNetworkGatewaySkuNameValues()
+}
+func PossibleVirtualNetworkGatewaySkuTierValues() []VirtualNetworkGatewaySkuTier {
+ return original.PossibleVirtualNetworkGatewaySkuTierValues()
+}
+func PossibleVirtualNetworkGatewayTypeValues() []VirtualNetworkGatewayType {
+ return original.PossibleVirtualNetworkGatewayTypeValues()
+}
+func PossibleVirtualNetworkPeeringStateValues() []VirtualNetworkPeeringState {
+ return original.PossibleVirtualNetworkPeeringStateValues()
+}
+func PossibleVpnClientProtocolValues() []VpnClientProtocol {
+ return original.PossibleVpnClientProtocolValues()
+}
+func PossibleVpnTypeValues() []VpnType {
+ return original.PossibleVpnTypeValues()
+}
+func UserAgent() string {
+ return original.UserAgent() + " profiles/2019-03-01"
+}
+func Version() string {
+ return original.Version()
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/storage/mgmt/storage/models.go b/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/storage/mgmt/storage/models.go
new file mode 100644
index 00000000000..7ac82e4e892
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/storage/mgmt/storage/models.go
@@ -0,0 +1,335 @@
+// +build go1.9
+
+// Copyright 2021 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This code was auto-generated by:
+// github.com/Azure/azure-sdk-for-go/tools/profileBuilder
+
+package storage
+
+import original "github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage"
+
+const (
+ DefaultBaseURI = original.DefaultBaseURI
+)
+
+type AccessTier = original.AccessTier
+
+const (
+ Cool AccessTier = original.Cool
+ Hot AccessTier = original.Hot
+)
+
+type AccountStatus = original.AccountStatus
+
+const (
+ Available AccountStatus = original.Available
+ Unavailable AccountStatus = original.Unavailable
+)
+
+type Action = original.Action
+
+const (
+ Allow Action = original.Allow
+)
+
+type Bypass = original.Bypass
+
+const (
+ AzureServices Bypass = original.AzureServices
+ Logging Bypass = original.Logging
+ Metrics Bypass = original.Metrics
+ None Bypass = original.None
+)
+
+type DefaultAction = original.DefaultAction
+
+const (
+ DefaultActionAllow DefaultAction = original.DefaultActionAllow
+ DefaultActionDeny DefaultAction = original.DefaultActionDeny
+)
+
+type HTTPProtocol = original.HTTPProtocol
+
+const (
+ HTTPS HTTPProtocol = original.HTTPS
+ Httpshttp HTTPProtocol = original.Httpshttp
+)
+
+type KeyPermission = original.KeyPermission
+
+const (
+ Full KeyPermission = original.Full
+ Read KeyPermission = original.Read
+)
+
+type KeySource = original.KeySource
+
+const (
+ MicrosoftKeyvault KeySource = original.MicrosoftKeyvault
+ MicrosoftStorage KeySource = original.MicrosoftStorage
+)
+
+type Kind = original.Kind
+
+const (
+ BlobStorage Kind = original.BlobStorage
+ Storage Kind = original.Storage
+ StorageV2 Kind = original.StorageV2
+)
+
+type Permissions = original.Permissions
+
+const (
+ A Permissions = original.A
+ C Permissions = original.C
+ D Permissions = original.D
+ L Permissions = original.L
+ P Permissions = original.P
+ R Permissions = original.R
+ U Permissions = original.U
+ W Permissions = original.W
+)
+
+type ProvisioningState = original.ProvisioningState
+
+const (
+ Creating ProvisioningState = original.Creating
+ ResolvingDNS ProvisioningState = original.ResolvingDNS
+ Succeeded ProvisioningState = original.Succeeded
+)
+
+type Reason = original.Reason
+
+const (
+ AccountNameInvalid Reason = original.AccountNameInvalid
+ AlreadyExists Reason = original.AlreadyExists
+)
+
+type ReasonCode = original.ReasonCode
+
+const (
+ NotAvailableForSubscription ReasonCode = original.NotAvailableForSubscription
+ QuotaID ReasonCode = original.QuotaID
+)
+
+type Services = original.Services
+
+const (
+ B Services = original.B
+ F Services = original.F
+ Q Services = original.Q
+ T Services = original.T
+)
+
+type SignedResource = original.SignedResource
+
+const (
+ SignedResourceB SignedResource = original.SignedResourceB
+ SignedResourceC SignedResource = original.SignedResourceC
+ SignedResourceF SignedResource = original.SignedResourceF
+ SignedResourceS SignedResource = original.SignedResourceS
+)
+
+type SignedResourceTypes = original.SignedResourceTypes
+
+const (
+ SignedResourceTypesC SignedResourceTypes = original.SignedResourceTypesC
+ SignedResourceTypesO SignedResourceTypes = original.SignedResourceTypesO
+ SignedResourceTypesS SignedResourceTypes = original.SignedResourceTypesS
+)
+
+type SkuName = original.SkuName
+
+const (
+ PremiumLRS SkuName = original.PremiumLRS
+ StandardGRS SkuName = original.StandardGRS
+ StandardLRS SkuName = original.StandardLRS
+ StandardRAGRS SkuName = original.StandardRAGRS
+ StandardZRS SkuName = original.StandardZRS
+)
+
+type SkuTier = original.SkuTier
+
+const (
+ Premium SkuTier = original.Premium
+ Standard SkuTier = original.Standard
+)
+
+type State = original.State
+
+const (
+ StateDeprovisioning State = original.StateDeprovisioning
+ StateFailed State = original.StateFailed
+ StateNetworkSourceDeleted State = original.StateNetworkSourceDeleted
+ StateProvisioning State = original.StateProvisioning
+ StateSucceeded State = original.StateSucceeded
+)
+
+type UsageUnit = original.UsageUnit
+
+const (
+ Bytes UsageUnit = original.Bytes
+ BytesPerSecond UsageUnit = original.BytesPerSecond
+ Count UsageUnit = original.Count
+ CountsPerSecond UsageUnit = original.CountsPerSecond
+ Percent UsageUnit = original.Percent
+ Seconds UsageUnit = original.Seconds
+)
+
+type Account = original.Account
+type AccountCheckNameAvailabilityParameters = original.AccountCheckNameAvailabilityParameters
+type AccountCreateParameters = original.AccountCreateParameters
+type AccountKey = original.AccountKey
+type AccountListKeysResult = original.AccountListKeysResult
+type AccountListResult = original.AccountListResult
+type AccountProperties = original.AccountProperties
+type AccountPropertiesCreateParameters = original.AccountPropertiesCreateParameters
+type AccountPropertiesUpdateParameters = original.AccountPropertiesUpdateParameters
+type AccountRegenerateKeyParameters = original.AccountRegenerateKeyParameters
+type AccountSasParameters = original.AccountSasParameters
+type AccountUpdateParameters = original.AccountUpdateParameters
+type AccountsClient = original.AccountsClient
+type AccountsCreateFuture = original.AccountsCreateFuture
+type BaseClient = original.BaseClient
+type CheckNameAvailabilityResult = original.CheckNameAvailabilityResult
+type CustomDomain = original.CustomDomain
+type Dimension = original.Dimension
+type Encryption = original.Encryption
+type EncryptionService = original.EncryptionService
+type EncryptionServices = original.EncryptionServices
+type Endpoints = original.Endpoints
+type IPRule = original.IPRule
+type Identity = original.Identity
+type KeyVaultProperties = original.KeyVaultProperties
+type ListAccountSasResponse = original.ListAccountSasResponse
+type ListServiceSasResponse = original.ListServiceSasResponse
+type MetricSpecification = original.MetricSpecification
+type NetworkRuleSet = original.NetworkRuleSet
+type Operation = original.Operation
+type OperationDisplay = original.OperationDisplay
+type OperationListResult = original.OperationListResult
+type OperationProperties = original.OperationProperties
+type OperationsClient = original.OperationsClient
+type Resource = original.Resource
+type Restriction = original.Restriction
+type SKUCapability = original.SKUCapability
+type ServiceSasParameters = original.ServiceSasParameters
+type ServiceSpecification = original.ServiceSpecification
+type Sku = original.Sku
+type SkuListResult = original.SkuListResult
+type SkusClient = original.SkusClient
+type Usage = original.Usage
+type UsageClient = original.UsageClient
+type UsageListResult = original.UsageListResult
+type UsageName = original.UsageName
+type VirtualNetworkRule = original.VirtualNetworkRule
+
+func New(subscriptionID string) BaseClient {
+ return original.New(subscriptionID)
+}
+func NewAccountsClient(subscriptionID string) AccountsClient {
+ return original.NewAccountsClient(subscriptionID)
+}
+func NewAccountsClientWithBaseURI(baseURI string, subscriptionID string) AccountsClient {
+ return original.NewAccountsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewOperationsClient(subscriptionID string) OperationsClient {
+ return original.NewOperationsClient(subscriptionID)
+}
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+ return original.NewOperationsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewSkusClient(subscriptionID string) SkusClient {
+ return original.NewSkusClient(subscriptionID)
+}
+func NewSkusClientWithBaseURI(baseURI string, subscriptionID string) SkusClient {
+ return original.NewSkusClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewUsageClient(subscriptionID string) UsageClient {
+ return original.NewUsageClient(subscriptionID)
+}
+func NewUsageClientWithBaseURI(baseURI string, subscriptionID string) UsageClient {
+ return original.NewUsageClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+ return original.NewWithBaseURI(baseURI, subscriptionID)
+}
+func PossibleAccessTierValues() []AccessTier {
+ return original.PossibleAccessTierValues()
+}
+func PossibleAccountStatusValues() []AccountStatus {
+ return original.PossibleAccountStatusValues()
+}
+func PossibleActionValues() []Action {
+ return original.PossibleActionValues()
+}
+func PossibleBypassValues() []Bypass {
+ return original.PossibleBypassValues()
+}
+func PossibleDefaultActionValues() []DefaultAction {
+ return original.PossibleDefaultActionValues()
+}
+func PossibleHTTPProtocolValues() []HTTPProtocol {
+ return original.PossibleHTTPProtocolValues()
+}
+func PossibleKeyPermissionValues() []KeyPermission {
+ return original.PossibleKeyPermissionValues()
+}
+func PossibleKeySourceValues() []KeySource {
+ return original.PossibleKeySourceValues()
+}
+func PossibleKindValues() []Kind {
+ return original.PossibleKindValues()
+}
+func PossiblePermissionsValues() []Permissions {
+ return original.PossiblePermissionsValues()
+}
+func PossibleProvisioningStateValues() []ProvisioningState {
+ return original.PossibleProvisioningStateValues()
+}
+func PossibleReasonCodeValues() []ReasonCode {
+ return original.PossibleReasonCodeValues()
+}
+func PossibleReasonValues() []Reason {
+ return original.PossibleReasonValues()
+}
+func PossibleServicesValues() []Services {
+ return original.PossibleServicesValues()
+}
+func PossibleSignedResourceTypesValues() []SignedResourceTypes {
+ return original.PossibleSignedResourceTypesValues()
+}
+func PossibleSignedResourceValues() []SignedResource {
+ return original.PossibleSignedResourceValues()
+}
+func PossibleSkuNameValues() []SkuName {
+ return original.PossibleSkuNameValues()
+}
+func PossibleSkuTierValues() []SkuTier {
+ return original.PossibleSkuTierValues()
+}
+func PossibleStateValues() []State {
+ return original.PossibleStateValues()
+}
+func PossibleUsageUnitValues() []UsageUnit {
+ return original.PossibleUsageUnitValues()
+}
+func UserAgent() string {
+ return original.UserAgent() + " profiles/2019-03-01"
+}
+func Version() string {
+ return original.Version()
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/CHANGELOG.md b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/CHANGELOG.md
new file mode 100644
index 00000000000..4e0a96bb58b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/CHANGELOG.md
@@ -0,0 +1,5 @@
+Generated from https://github.com/Azure/azure-rest-api-specs/tree/3c764635e7d442b3e74caf593029fcd440b3ef82//specification/compute/resource-manager/readme.md tag: `package-compute-2017-12`
+
+Code generator @microsoft.azure/autorest.go@2.1.171
+
+
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/availabilitysets.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/availabilitysets.go
new file mode 100644
index 00000000000..309cbf3ae7b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/availabilitysets.go
@@ -0,0 +1,664 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// AvailabilitySetsClient is the compute Client
+type AvailabilitySetsClient struct {
+ BaseClient
+}
+
+// NewAvailabilitySetsClient creates an instance of the AvailabilitySetsClient client.
+func NewAvailabilitySetsClient(subscriptionID string) AvailabilitySetsClient {
+ return NewAvailabilitySetsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewAvailabilitySetsClientWithBaseURI creates an instance of the AvailabilitySetsClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewAvailabilitySetsClientWithBaseURI(baseURI string, subscriptionID string) AvailabilitySetsClient {
+ return AvailabilitySetsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or update an availability set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// availabilitySetName - the name of the availability set.
+// parameters - parameters supplied to the Create Availability Set operation.
+func (client AvailabilitySetsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, availabilitySetName string, parameters AvailabilitySet) (result AvailabilitySet, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, availabilitySetName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "CreateOrUpdate", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client AvailabilitySetsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, availabilitySetName string, parameters AvailabilitySet) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "availabilitySetName": autorest.Encode("path", availabilitySetName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/availabilitySets/{availabilitySetName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailabilitySetsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client AvailabilitySetsClient) CreateOrUpdateResponder(resp *http.Response) (result AvailabilitySet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete delete an availability set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// availabilitySetName - the name of the availability set.
+func (client AvailabilitySetsClient) Delete(ctx context.Context, resourceGroupName string, availabilitySetName string) (result OperationStatusResponse, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, availabilitySetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Delete", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client AvailabilitySetsClient) DeletePreparer(ctx context.Context, resourceGroupName string, availabilitySetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "availabilitySetName": autorest.Encode("path", availabilitySetName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/availabilitySets/{availabilitySetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailabilitySetsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client AvailabilitySetsClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get retrieves information about an availability set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// availabilitySetName - the name of the availability set.
+func (client AvailabilitySetsClient) Get(ctx context.Context, resourceGroupName string, availabilitySetName string) (result AvailabilitySet, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, availabilitySetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client AvailabilitySetsClient) GetPreparer(ctx context.Context, resourceGroupName string, availabilitySetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "availabilitySetName": autorest.Encode("path", availabilitySetName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/availabilitySets/{availabilitySetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailabilitySetsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client AvailabilitySetsClient) GetResponder(resp *http.Response) (result AvailabilitySet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all availability sets in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client AvailabilitySetsClient) List(ctx context.Context, resourceGroupName string) (result AvailabilitySetListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.List")
+ defer func() {
+ sc := -1
+ if result.aslr.Response.Response != nil {
+ sc = result.aslr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.aslr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.aslr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.aslr.hasNextLink() && result.aslr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client AvailabilitySetsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/availabilitySets", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailabilitySetsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client AvailabilitySetsClient) ListResponder(resp *http.Response) (result AvailabilitySetListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client AvailabilitySetsClient) listNextResults(ctx context.Context, lastResults AvailabilitySetListResult) (result AvailabilitySetListResult, err error) {
+ req, err := lastResults.availabilitySetListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client AvailabilitySetsClient) ListComplete(ctx context.Context, resourceGroupName string) (result AvailabilitySetListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAvailableSizes lists all available virtual machine sizes that can be used to create a new virtual machine in an
+// existing availability set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// availabilitySetName - the name of the availability set.
+func (client AvailabilitySetsClient) ListAvailableSizes(ctx context.Context, resourceGroupName string, availabilitySetName string) (result VirtualMachineSizeListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.ListAvailableSizes")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListAvailableSizesPreparer(ctx, resourceGroupName, availabilitySetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "ListAvailableSizes", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAvailableSizesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "ListAvailableSizes", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAvailableSizesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "ListAvailableSizes", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListAvailableSizesPreparer prepares the ListAvailableSizes request.
+func (client AvailabilitySetsClient) ListAvailableSizesPreparer(ctx context.Context, resourceGroupName string, availabilitySetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "availabilitySetName": autorest.Encode("path", availabilitySetName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/availabilitySets/{availabilitySetName}/vmSizes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAvailableSizesSender sends the ListAvailableSizes request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailabilitySetsClient) ListAvailableSizesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAvailableSizesResponder handles the response to the ListAvailableSizes request. The method always
+// closes the http.Response Body.
+func (client AvailabilitySetsClient) ListAvailableSizesResponder(resp *http.Response) (result VirtualMachineSizeListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListBySubscription lists all availability sets in a subscription.
+// Parameters:
+// expand - the expand expression to apply to the operation. Allowed values are 'instanceView'.
+func (client AvailabilitySetsClient) ListBySubscription(ctx context.Context, expand string) (result AvailabilitySetListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.ListBySubscription")
+ defer func() {
+ sc := -1
+ if result.aslr.Response.Response != nil {
+ sc = result.aslr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listBySubscriptionNextResults
+ req, err := client.ListBySubscriptionPreparer(ctx, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "ListBySubscription", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListBySubscriptionSender(req)
+ if err != nil {
+ result.aslr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "ListBySubscription", resp, "Failure sending request")
+ return
+ }
+
+ result.aslr, err = client.ListBySubscriptionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "ListBySubscription", resp, "Failure responding to request")
+ return
+ }
+ if result.aslr.hasNextLink() && result.aslr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListBySubscriptionPreparer prepares the ListBySubscription request.
+func (client AvailabilitySetsClient) ListBySubscriptionPreparer(ctx context.Context, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/availabilitySets", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListBySubscriptionSender sends the ListBySubscription request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailabilitySetsClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
+// closes the http.Response Body.
+func (client AvailabilitySetsClient) ListBySubscriptionResponder(resp *http.Response) (result AvailabilitySetListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listBySubscriptionNextResults retrieves the next set of results, if any.
+func (client AvailabilitySetsClient) listBySubscriptionNextResults(ctx context.Context, lastResults AvailabilitySetListResult) (result AvailabilitySetListResult, err error) {
+ req, err := lastResults.availabilitySetListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListBySubscriptionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListBySubscriptionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
+func (client AvailabilitySetsClient) ListBySubscriptionComplete(ctx context.Context, expand string) (result AvailabilitySetListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.ListBySubscription")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListBySubscription(ctx, expand)
+ return
+}
+
+// Update update an availability set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// availabilitySetName - the name of the availability set.
+// parameters - parameters supplied to the Update Availability Set operation.
+func (client AvailabilitySetsClient) Update(ctx context.Context, resourceGroupName string, availabilitySetName string, parameters AvailabilitySetUpdate) (result AvailabilitySet, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetsClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, availabilitySetName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Update", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.AvailabilitySetsClient", "Update", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client AvailabilitySetsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, availabilitySetName string, parameters AvailabilitySetUpdate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "availabilitySetName": autorest.Encode("path", availabilitySetName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/availabilitySets/{availabilitySetName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailabilitySetsClient) UpdateSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client AvailabilitySetsClient) UpdateResponder(resp *http.Response) (result AvailabilitySet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/client.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/client.go
new file mode 100644
index 00000000000..d9d0430190e
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/client.go
@@ -0,0 +1,52 @@
+// Package compute implements the Azure ARM Compute service API version .
+//
+// Compute Client
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+)
+
+const (
+ // DefaultBaseURI is the default URI used for the service Compute
+ DefaultBaseURI = "https://management.azure.com"
+)
+
+// BaseClient is the base client for Compute.
+type BaseClient struct {
+ autorest.Client
+ BaseURI string
+ SubscriptionID string
+}
+
+// New creates an instance of the BaseClient client.
+func New(subscriptionID string) BaseClient {
+ return NewWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint. Use this when interacting with
+// an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+ return BaseClient{
+ Client: autorest.NewClientWithUserAgent(UserAgent()),
+ BaseURI: baseURI,
+ SubscriptionID: subscriptionID,
+ }
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/disks.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/disks.go
new file mode 100644
index 00000000000..ad57a5a0804
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/disks.go
@@ -0,0 +1,902 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// DisksClient is the compute Client
+type DisksClient struct {
+ BaseClient
+}
+
+// NewDisksClient creates an instance of the DisksClient client.
+func NewDisksClient(subscriptionID string) DisksClient {
+ return NewDisksClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewDisksClientWithBaseURI creates an instance of the DisksClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewDisksClientWithBaseURI(baseURI string, subscriptionID string) DisksClient {
+ return DisksClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a disk.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
+// created. Supported characters for the name are a-z, A-Z, 0-9 and _. The maximum name length is 80
+// characters.
+// disk - disk object supplied in the body of the Put disk operation.
+func (client DisksClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, diskName string, disk Disk) (result DisksCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: disk,
+ Constraints: []validation.Constraint{{Target: "disk.DiskProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "disk.DiskProperties.CreationData", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "disk.DiskProperties.CreationData.ImageReference", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "disk.DiskProperties.CreationData.ImageReference.ID", Name: validation.Null, Rule: true, Chain: nil}}},
+ }},
+ {Target: "disk.DiskProperties.EncryptionSettings", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "disk.DiskProperties.EncryptionSettings.DiskEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "disk.DiskProperties.EncryptionSettings.DiskEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "disk.DiskProperties.EncryptionSettings.DiskEncryptionKey.SecretURL", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "disk.DiskProperties.EncryptionSettings.KeyEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "disk.DiskProperties.EncryptionSettings.KeyEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "disk.DiskProperties.EncryptionSettings.KeyEncryptionKey.KeyURL", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("compute.DisksClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, diskName, disk)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client DisksClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, diskName string, disk Disk) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "diskName": autorest.Encode("path", diskName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ disk.ManagedBy = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
+ autorest.WithJSON(disk),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) CreateOrUpdateSender(req *http.Request) (future DisksCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client DisksClient) (d Disk, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.DisksCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ d.Response.Response, err = future.GetResult(sender)
+ if d.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && d.Response.Response.StatusCode != http.StatusNoContent {
+ d, err = client.CreateOrUpdateResponder(d.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksCreateOrUpdateFuture", "Result", d.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client DisksClient) CreateOrUpdateResponder(resp *http.Response) (result Disk, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes a disk.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
+// created. Supported characters for the name are a-z, A-Z, 0-9 and _. The maximum name length is 80
+// characters.
+func (client DisksClient) Delete(ctx context.Context, resourceGroupName string, diskName string) (result DisksDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, diskName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client DisksClient) DeletePreparer(ctx context.Context, resourceGroupName string, diskName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "diskName": autorest.Encode("path", diskName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) DeleteSender(req *http.Request) (future DisksDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client DisksClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.DisksDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client DisksClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get gets information about a disk.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
+// created. Supported characters for the name are a-z, A-Z, 0-9 and _. The maximum name length is 80
+// characters.
+func (client DisksClient) Get(ctx context.Context, resourceGroupName string, diskName string) (result Disk, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, diskName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client DisksClient) GetPreparer(ctx context.Context, resourceGroupName string, diskName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "diskName": autorest.Encode("path", diskName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client DisksClient) GetResponder(resp *http.Response) (result Disk, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GrantAccess grants access to a disk.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
+// created. Supported characters for the name are a-z, A-Z, 0-9 and _. The maximum name length is 80
+// characters.
+// grantAccessData - access data object supplied in the body of the get disk access operation.
+func (client DisksClient) GrantAccess(ctx context.Context, resourceGroupName string, diskName string, grantAccessData GrantAccessData) (result DisksGrantAccessFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.GrantAccess")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: grantAccessData,
+ Constraints: []validation.Constraint{{Target: "grantAccessData.DurationInSeconds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.DisksClient", "GrantAccess", err.Error())
+ }
+
+ req, err := client.GrantAccessPreparer(ctx, resourceGroupName, diskName, grantAccessData)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "GrantAccess", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GrantAccessSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "GrantAccess", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GrantAccessPreparer prepares the GrantAccess request.
+func (client DisksClient) GrantAccessPreparer(ctx context.Context, resourceGroupName string, diskName string, grantAccessData GrantAccessData) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "diskName": autorest.Encode("path", diskName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}/beginGetAccess", pathParameters),
+ autorest.WithJSON(grantAccessData),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GrantAccessSender sends the GrantAccess request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) GrantAccessSender(req *http.Request) (future DisksGrantAccessFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client DisksClient) (au AccessURI, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksGrantAccessFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.DisksGrantAccessFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ au.Response.Response, err = future.GetResult(sender)
+ if au.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksGrantAccessFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && au.Response.Response.StatusCode != http.StatusNoContent {
+ au, err = client.GrantAccessResponder(au.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksGrantAccessFuture", "Result", au.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GrantAccessResponder handles the response to the GrantAccess request. The method always
+// closes the http.Response Body.
+func (client DisksClient) GrantAccessResponder(resp *http.Response) (result AccessURI, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all the disks under a subscription.
+func (client DisksClient) List(ctx context.Context) (result DiskListPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.List")
+ defer func() {
+ sc := -1
+ if result.dl.Response.Response != nil {
+ sc = result.dl.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.dl.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.dl, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.dl.hasNextLink() && result.dl.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client DisksClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/disks", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client DisksClient) ListResponder(resp *http.Response) (result DiskList, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client DisksClient) listNextResults(ctx context.Context, lastResults DiskList) (result DiskList, err error) {
+ req, err := lastResults.diskListPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client DisksClient) ListComplete(ctx context.Context) (result DiskListIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
+
+// ListByResourceGroup lists all the disks under a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client DisksClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result DiskListPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.dl.Response.Response != nil {
+ sc = result.dl.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listByResourceGroupNextResults
+ req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.dl.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result.dl, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "ListByResourceGroup", resp, "Failure responding to request")
+ return
+ }
+ if result.dl.hasNextLink() && result.dl.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client DisksClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client DisksClient) ListByResourceGroupResponder(resp *http.Response) (result DiskList, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByResourceGroupNextResults retrieves the next set of results, if any.
+func (client DisksClient) listByResourceGroupNextResults(ctx context.Context, lastResults DiskList) (result DiskList, err error) {
+ req, err := lastResults.diskListPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
+func (client DisksClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result DiskListIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
+ return
+}
+
+// RevokeAccess revokes access to a disk.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
+// created. Supported characters for the name are a-z, A-Z, 0-9 and _. The maximum name length is 80
+// characters.
+func (client DisksClient) RevokeAccess(ctx context.Context, resourceGroupName string, diskName string) (result DisksRevokeAccessFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.RevokeAccess")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RevokeAccessPreparer(ctx, resourceGroupName, diskName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "RevokeAccess", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RevokeAccessSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "RevokeAccess", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RevokeAccessPreparer prepares the RevokeAccess request.
+func (client DisksClient) RevokeAccessPreparer(ctx context.Context, resourceGroupName string, diskName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "diskName": autorest.Encode("path", diskName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}/endGetAccess", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RevokeAccessSender sends the RevokeAccess request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) RevokeAccessSender(req *http.Request) (future DisksRevokeAccessFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client DisksClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksRevokeAccessFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.DisksRevokeAccessFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksRevokeAccessFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RevokeAccessResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksRevokeAccessFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RevokeAccessResponder handles the response to the RevokeAccess request. The method always
+// closes the http.Response Body.
+func (client DisksClient) RevokeAccessResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update updates (patches) a disk.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
+// created. Supported characters for the name are a-z, A-Z, 0-9 and _. The maximum name length is 80
+// characters.
+// disk - disk object supplied in the body of the Patch disk operation.
+func (client DisksClient) Update(ctx context.Context, resourceGroupName string, diskName string, disk DiskUpdate) (result DisksUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, diskName, disk)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client DisksClient) UpdatePreparer(ctx context.Context, resourceGroupName string, diskName string, disk DiskUpdate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "diskName": autorest.Encode("path", diskName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
+ autorest.WithJSON(disk),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client DisksClient) UpdateSender(req *http.Request) (future DisksUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client DisksClient) (d Disk, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.DisksUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ d.Response.Response, err = future.GetResult(sender)
+ if d.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && d.Response.Response.StatusCode != http.StatusNoContent {
+ d, err = client.UpdateResponder(d.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.DisksUpdateFuture", "Result", d.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client DisksClient) UpdateResponder(resp *http.Response) (result Disk, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/enums.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/enums.go
new file mode 100644
index 00000000000..d61a11c06a1
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/enums.go
@@ -0,0 +1,813 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// AccessLevel enumerates the values for access level.
+type AccessLevel string
+
+const (
+ // None ...
+ None AccessLevel = "None"
+ // Read ...
+ Read AccessLevel = "Read"
+)
+
+// PossibleAccessLevelValues returns an array of possible values for the AccessLevel const type.
+func PossibleAccessLevelValues() []AccessLevel {
+ return []AccessLevel{None, Read}
+}
+
+// CachingTypes enumerates the values for caching types.
+type CachingTypes string
+
+const (
+ // CachingTypesNone ...
+ CachingTypesNone CachingTypes = "None"
+ // CachingTypesReadOnly ...
+ CachingTypesReadOnly CachingTypes = "ReadOnly"
+ // CachingTypesReadWrite ...
+ CachingTypesReadWrite CachingTypes = "ReadWrite"
+)
+
+// PossibleCachingTypesValues returns an array of possible values for the CachingTypes const type.
+func PossibleCachingTypesValues() []CachingTypes {
+ return []CachingTypes{CachingTypesNone, CachingTypesReadOnly, CachingTypesReadWrite}
+}
+
+// ComponentNames enumerates the values for component names.
+type ComponentNames string
+
+const (
+ // MicrosoftWindowsShellSetup ...
+ MicrosoftWindowsShellSetup ComponentNames = "Microsoft-Windows-Shell-Setup"
+)
+
+// PossibleComponentNamesValues returns an array of possible values for the ComponentNames const type.
+func PossibleComponentNamesValues() []ComponentNames {
+ return []ComponentNames{MicrosoftWindowsShellSetup}
+}
+
+// DiskCreateOption enumerates the values for disk create option.
+type DiskCreateOption string
+
+const (
+ // Attach ...
+ Attach DiskCreateOption = "Attach"
+ // Copy ...
+ Copy DiskCreateOption = "Copy"
+ // Empty ...
+ Empty DiskCreateOption = "Empty"
+ // FromImage ...
+ FromImage DiskCreateOption = "FromImage"
+ // Import ...
+ Import DiskCreateOption = "Import"
+)
+
+// PossibleDiskCreateOptionValues returns an array of possible values for the DiskCreateOption const type.
+func PossibleDiskCreateOptionValues() []DiskCreateOption {
+ return []DiskCreateOption{Attach, Copy, Empty, FromImage, Import}
+}
+
+// DiskCreateOptionTypes enumerates the values for disk create option types.
+type DiskCreateOptionTypes string
+
+const (
+ // DiskCreateOptionTypesAttach ...
+ DiskCreateOptionTypesAttach DiskCreateOptionTypes = "Attach"
+ // DiskCreateOptionTypesEmpty ...
+ DiskCreateOptionTypesEmpty DiskCreateOptionTypes = "Empty"
+ // DiskCreateOptionTypesFromImage ...
+ DiskCreateOptionTypesFromImage DiskCreateOptionTypes = "FromImage"
+)
+
+// PossibleDiskCreateOptionTypesValues returns an array of possible values for the DiskCreateOptionTypes const type.
+func PossibleDiskCreateOptionTypesValues() []DiskCreateOptionTypes {
+ return []DiskCreateOptionTypes{DiskCreateOptionTypesAttach, DiskCreateOptionTypesEmpty, DiskCreateOptionTypesFromImage}
+}
+
+// InstanceViewTypes enumerates the values for instance view types.
+type InstanceViewTypes string
+
+const (
+ // InstanceView ...
+ InstanceView InstanceViewTypes = "instanceView"
+)
+
+// PossibleInstanceViewTypesValues returns an array of possible values for the InstanceViewTypes const type.
+func PossibleInstanceViewTypesValues() []InstanceViewTypes {
+ return []InstanceViewTypes{InstanceView}
+}
+
+// IntervalInMins enumerates the values for interval in mins.
+type IntervalInMins string
+
+const (
+ // FiveMins ...
+ FiveMins IntervalInMins = "FiveMins"
+ // SixtyMins ...
+ SixtyMins IntervalInMins = "SixtyMins"
+ // ThirtyMins ...
+ ThirtyMins IntervalInMins = "ThirtyMins"
+ // ThreeMins ...
+ ThreeMins IntervalInMins = "ThreeMins"
+)
+
+// PossibleIntervalInMinsValues returns an array of possible values for the IntervalInMins const type.
+func PossibleIntervalInMinsValues() []IntervalInMins {
+ return []IntervalInMins{FiveMins, SixtyMins, ThirtyMins, ThreeMins}
+}
+
+// IPVersion enumerates the values for ip version.
+type IPVersion string
+
+const (
+ // IPv4 ...
+ IPv4 IPVersion = "IPv4"
+ // IPv6 ...
+ IPv6 IPVersion = "IPv6"
+)
+
+// PossibleIPVersionValues returns an array of possible values for the IPVersion const type.
+func PossibleIPVersionValues() []IPVersion {
+ return []IPVersion{IPv4, IPv6}
+}
+
+// MaintenanceOperationResultCodeTypes enumerates the values for maintenance operation result code types.
+type MaintenanceOperationResultCodeTypes string
+
+const (
+ // MaintenanceOperationResultCodeTypesMaintenanceAborted ...
+ MaintenanceOperationResultCodeTypesMaintenanceAborted MaintenanceOperationResultCodeTypes = "MaintenanceAborted"
+ // MaintenanceOperationResultCodeTypesMaintenanceCompleted ...
+ MaintenanceOperationResultCodeTypesMaintenanceCompleted MaintenanceOperationResultCodeTypes = "MaintenanceCompleted"
+ // MaintenanceOperationResultCodeTypesNone ...
+ MaintenanceOperationResultCodeTypesNone MaintenanceOperationResultCodeTypes = "None"
+ // MaintenanceOperationResultCodeTypesRetryLater ...
+ MaintenanceOperationResultCodeTypesRetryLater MaintenanceOperationResultCodeTypes = "RetryLater"
+)
+
+// PossibleMaintenanceOperationResultCodeTypesValues returns an array of possible values for the MaintenanceOperationResultCodeTypes const type.
+func PossibleMaintenanceOperationResultCodeTypesValues() []MaintenanceOperationResultCodeTypes {
+ return []MaintenanceOperationResultCodeTypes{MaintenanceOperationResultCodeTypesMaintenanceAborted, MaintenanceOperationResultCodeTypesMaintenanceCompleted, MaintenanceOperationResultCodeTypesNone, MaintenanceOperationResultCodeTypesRetryLater}
+}
+
+// OperatingSystemStateTypes enumerates the values for operating system state types.
+type OperatingSystemStateTypes string
+
+const (
+ // Generalized ...
+ Generalized OperatingSystemStateTypes = "Generalized"
+ // Specialized ...
+ Specialized OperatingSystemStateTypes = "Specialized"
+)
+
+// PossibleOperatingSystemStateTypesValues returns an array of possible values for the OperatingSystemStateTypes const type.
+func PossibleOperatingSystemStateTypesValues() []OperatingSystemStateTypes {
+ return []OperatingSystemStateTypes{Generalized, Specialized}
+}
+
+// OperatingSystemTypes enumerates the values for operating system types.
+type OperatingSystemTypes string
+
+const (
+ // Linux ...
+ Linux OperatingSystemTypes = "Linux"
+ // Windows ...
+ Windows OperatingSystemTypes = "Windows"
+)
+
+// PossibleOperatingSystemTypesValues returns an array of possible values for the OperatingSystemTypes const type.
+func PossibleOperatingSystemTypesValues() []OperatingSystemTypes {
+ return []OperatingSystemTypes{Linux, Windows}
+}
+
+// PassNames enumerates the values for pass names.
+type PassNames string
+
+const (
+ // OobeSystem ...
+ OobeSystem PassNames = "OobeSystem"
+)
+
+// PossiblePassNamesValues returns an array of possible values for the PassNames const type.
+func PossiblePassNamesValues() []PassNames {
+ return []PassNames{OobeSystem}
+}
+
+// ProtocolTypes enumerates the values for protocol types.
+type ProtocolTypes string
+
+const (
+ // HTTP ...
+ HTTP ProtocolTypes = "Http"
+ // HTTPS ...
+ HTTPS ProtocolTypes = "Https"
+)
+
+// PossibleProtocolTypesValues returns an array of possible values for the ProtocolTypes const type.
+func PossibleProtocolTypesValues() []ProtocolTypes {
+ return []ProtocolTypes{HTTP, HTTPS}
+}
+
+// ResourceIdentityType enumerates the values for resource identity type.
+type ResourceIdentityType string
+
+const (
+ // ResourceIdentityTypeNone ...
+ ResourceIdentityTypeNone ResourceIdentityType = "None"
+ // ResourceIdentityTypeSystemAssigned ...
+ ResourceIdentityTypeSystemAssigned ResourceIdentityType = "SystemAssigned"
+ // ResourceIdentityTypeSystemAssignedUserAssigned ...
+ ResourceIdentityTypeSystemAssignedUserAssigned ResourceIdentityType = "SystemAssigned, UserAssigned"
+ // ResourceIdentityTypeUserAssigned ...
+ ResourceIdentityTypeUserAssigned ResourceIdentityType = "UserAssigned"
+)
+
+// PossibleResourceIdentityTypeValues returns an array of possible values for the ResourceIdentityType const type.
+func PossibleResourceIdentityTypeValues() []ResourceIdentityType {
+ return []ResourceIdentityType{ResourceIdentityTypeNone, ResourceIdentityTypeSystemAssigned, ResourceIdentityTypeSystemAssignedUserAssigned, ResourceIdentityTypeUserAssigned}
+}
+
+// ResourceSkuCapacityScaleType enumerates the values for resource sku capacity scale type.
+type ResourceSkuCapacityScaleType string
+
+const (
+ // ResourceSkuCapacityScaleTypeAutomatic ...
+ ResourceSkuCapacityScaleTypeAutomatic ResourceSkuCapacityScaleType = "Automatic"
+ // ResourceSkuCapacityScaleTypeManual ...
+ ResourceSkuCapacityScaleTypeManual ResourceSkuCapacityScaleType = "Manual"
+ // ResourceSkuCapacityScaleTypeNone ...
+ ResourceSkuCapacityScaleTypeNone ResourceSkuCapacityScaleType = "None"
+)
+
+// PossibleResourceSkuCapacityScaleTypeValues returns an array of possible values for the ResourceSkuCapacityScaleType const type.
+func PossibleResourceSkuCapacityScaleTypeValues() []ResourceSkuCapacityScaleType {
+ return []ResourceSkuCapacityScaleType{ResourceSkuCapacityScaleTypeAutomatic, ResourceSkuCapacityScaleTypeManual, ResourceSkuCapacityScaleTypeNone}
+}
+
+// ResourceSkuRestrictionsReasonCode enumerates the values for resource sku restrictions reason code.
+type ResourceSkuRestrictionsReasonCode string
+
+const (
+ // NotAvailableForSubscription ...
+ NotAvailableForSubscription ResourceSkuRestrictionsReasonCode = "NotAvailableForSubscription"
+ // QuotaID ...
+ QuotaID ResourceSkuRestrictionsReasonCode = "QuotaId"
+)
+
+// PossibleResourceSkuRestrictionsReasonCodeValues returns an array of possible values for the ResourceSkuRestrictionsReasonCode const type.
+func PossibleResourceSkuRestrictionsReasonCodeValues() []ResourceSkuRestrictionsReasonCode {
+ return []ResourceSkuRestrictionsReasonCode{NotAvailableForSubscription, QuotaID}
+}
+
+// ResourceSkuRestrictionsType enumerates the values for resource sku restrictions type.
+type ResourceSkuRestrictionsType string
+
+const (
+ // Location ...
+ Location ResourceSkuRestrictionsType = "Location"
+ // Zone ...
+ Zone ResourceSkuRestrictionsType = "Zone"
+)
+
+// PossibleResourceSkuRestrictionsTypeValues returns an array of possible values for the ResourceSkuRestrictionsType const type.
+func PossibleResourceSkuRestrictionsTypeValues() []ResourceSkuRestrictionsType {
+ return []ResourceSkuRestrictionsType{Location, Zone}
+}
+
+// RollingUpgradeActionType enumerates the values for rolling upgrade action type.
+type RollingUpgradeActionType string
+
+const (
+ // Cancel ...
+ Cancel RollingUpgradeActionType = "Cancel"
+ // Start ...
+ Start RollingUpgradeActionType = "Start"
+)
+
+// PossibleRollingUpgradeActionTypeValues returns an array of possible values for the RollingUpgradeActionType const type.
+func PossibleRollingUpgradeActionTypeValues() []RollingUpgradeActionType {
+ return []RollingUpgradeActionType{Cancel, Start}
+}
+
+// RollingUpgradeStatusCode enumerates the values for rolling upgrade status code.
+type RollingUpgradeStatusCode string
+
+const (
+ // Cancelled ...
+ Cancelled RollingUpgradeStatusCode = "Cancelled"
+ // Completed ...
+ Completed RollingUpgradeStatusCode = "Completed"
+ // Faulted ...
+ Faulted RollingUpgradeStatusCode = "Faulted"
+ // RollingForward ...
+ RollingForward RollingUpgradeStatusCode = "RollingForward"
+)
+
+// PossibleRollingUpgradeStatusCodeValues returns an array of possible values for the RollingUpgradeStatusCode const type.
+func PossibleRollingUpgradeStatusCodeValues() []RollingUpgradeStatusCode {
+ return []RollingUpgradeStatusCode{Cancelled, Completed, Faulted, RollingForward}
+}
+
+// SettingNames enumerates the values for setting names.
+type SettingNames string
+
+const (
+ // AutoLogon ...
+ AutoLogon SettingNames = "AutoLogon"
+ // FirstLogonCommands ...
+ FirstLogonCommands SettingNames = "FirstLogonCommands"
+)
+
+// PossibleSettingNamesValues returns an array of possible values for the SettingNames const type.
+func PossibleSettingNamesValues() []SettingNames {
+ return []SettingNames{AutoLogon, FirstLogonCommands}
+}
+
+// StatusLevelTypes enumerates the values for status level types.
+type StatusLevelTypes string
+
+const (
+ // Error ...
+ Error StatusLevelTypes = "Error"
+ // Info ...
+ Info StatusLevelTypes = "Info"
+ // Warning ...
+ Warning StatusLevelTypes = "Warning"
+)
+
+// PossibleStatusLevelTypesValues returns an array of possible values for the StatusLevelTypes const type.
+func PossibleStatusLevelTypesValues() []StatusLevelTypes {
+ return []StatusLevelTypes{Error, Info, Warning}
+}
+
+// StorageAccountTypes enumerates the values for storage account types.
+type StorageAccountTypes string
+
+const (
+ // PremiumLRS ...
+ PremiumLRS StorageAccountTypes = "Premium_LRS"
+ // StandardLRS ...
+ StandardLRS StorageAccountTypes = "Standard_LRS"
+)
+
+// PossibleStorageAccountTypesValues returns an array of possible values for the StorageAccountTypes const type.
+func PossibleStorageAccountTypesValues() []StorageAccountTypes {
+ return []StorageAccountTypes{PremiumLRS, StandardLRS}
+}
+
+// UpgradeMode enumerates the values for upgrade mode.
+type UpgradeMode string
+
+const (
+ // Automatic ...
+ Automatic UpgradeMode = "Automatic"
+ // Manual ...
+ Manual UpgradeMode = "Manual"
+ // Rolling ...
+ Rolling UpgradeMode = "Rolling"
+)
+
+// PossibleUpgradeModeValues returns an array of possible values for the UpgradeMode const type.
+func PossibleUpgradeModeValues() []UpgradeMode {
+ return []UpgradeMode{Automatic, Manual, Rolling}
+}
+
+// UpgradeOperationInvoker enumerates the values for upgrade operation invoker.
+type UpgradeOperationInvoker string
+
+const (
+ // Platform ...
+ Platform UpgradeOperationInvoker = "Platform"
+ // Unknown ...
+ Unknown UpgradeOperationInvoker = "Unknown"
+ // User ...
+ User UpgradeOperationInvoker = "User"
+)
+
+// PossibleUpgradeOperationInvokerValues returns an array of possible values for the UpgradeOperationInvoker const type.
+func PossibleUpgradeOperationInvokerValues() []UpgradeOperationInvoker {
+ return []UpgradeOperationInvoker{Platform, Unknown, User}
+}
+
+// UpgradeState enumerates the values for upgrade state.
+type UpgradeState string
+
+const (
+ // UpgradeStateCancelled ...
+ UpgradeStateCancelled UpgradeState = "Cancelled"
+ // UpgradeStateCompleted ...
+ UpgradeStateCompleted UpgradeState = "Completed"
+ // UpgradeStateFaulted ...
+ UpgradeStateFaulted UpgradeState = "Faulted"
+ // UpgradeStateRollingForward ...
+ UpgradeStateRollingForward UpgradeState = "RollingForward"
+)
+
+// PossibleUpgradeStateValues returns an array of possible values for the UpgradeState const type.
+func PossibleUpgradeStateValues() []UpgradeState {
+ return []UpgradeState{UpgradeStateCancelled, UpgradeStateCompleted, UpgradeStateFaulted, UpgradeStateRollingForward}
+}
+
+// VirtualMachineEvictionPolicyTypes enumerates the values for virtual machine eviction policy types.
+type VirtualMachineEvictionPolicyTypes string
+
+const (
+ // Deallocate ...
+ Deallocate VirtualMachineEvictionPolicyTypes = "Deallocate"
+ // Delete ...
+ Delete VirtualMachineEvictionPolicyTypes = "Delete"
+)
+
+// PossibleVirtualMachineEvictionPolicyTypesValues returns an array of possible values for the VirtualMachineEvictionPolicyTypes const type.
+func PossibleVirtualMachineEvictionPolicyTypesValues() []VirtualMachineEvictionPolicyTypes {
+ return []VirtualMachineEvictionPolicyTypes{Deallocate, Delete}
+}
+
+// VirtualMachinePriorityTypes enumerates the values for virtual machine priority types.
+type VirtualMachinePriorityTypes string
+
+const (
+ // Low ...
+ Low VirtualMachinePriorityTypes = "Low"
+ // Regular ...
+ Regular VirtualMachinePriorityTypes = "Regular"
+)
+
+// PossibleVirtualMachinePriorityTypesValues returns an array of possible values for the VirtualMachinePriorityTypes const type.
+func PossibleVirtualMachinePriorityTypesValues() []VirtualMachinePriorityTypes {
+ return []VirtualMachinePriorityTypes{Low, Regular}
+}
+
+// VirtualMachineScaleSetSkuScaleType enumerates the values for virtual machine scale set sku scale type.
+type VirtualMachineScaleSetSkuScaleType string
+
+const (
+ // VirtualMachineScaleSetSkuScaleTypeAutomatic ...
+ VirtualMachineScaleSetSkuScaleTypeAutomatic VirtualMachineScaleSetSkuScaleType = "Automatic"
+ // VirtualMachineScaleSetSkuScaleTypeNone ...
+ VirtualMachineScaleSetSkuScaleTypeNone VirtualMachineScaleSetSkuScaleType = "None"
+)
+
+// PossibleVirtualMachineScaleSetSkuScaleTypeValues returns an array of possible values for the VirtualMachineScaleSetSkuScaleType const type.
+func PossibleVirtualMachineScaleSetSkuScaleTypeValues() []VirtualMachineScaleSetSkuScaleType {
+ return []VirtualMachineScaleSetSkuScaleType{VirtualMachineScaleSetSkuScaleTypeAutomatic, VirtualMachineScaleSetSkuScaleTypeNone}
+}
+
+// VirtualMachineSizeTypes enumerates the values for virtual machine size types.
+type VirtualMachineSizeTypes string
+
+const (
+ // BasicA0 ...
+ BasicA0 VirtualMachineSizeTypes = "Basic_A0"
+ // BasicA1 ...
+ BasicA1 VirtualMachineSizeTypes = "Basic_A1"
+ // BasicA2 ...
+ BasicA2 VirtualMachineSizeTypes = "Basic_A2"
+ // BasicA3 ...
+ BasicA3 VirtualMachineSizeTypes = "Basic_A3"
+ // BasicA4 ...
+ BasicA4 VirtualMachineSizeTypes = "Basic_A4"
+ // StandardA0 ...
+ StandardA0 VirtualMachineSizeTypes = "Standard_A0"
+ // StandardA1 ...
+ StandardA1 VirtualMachineSizeTypes = "Standard_A1"
+ // StandardA10 ...
+ StandardA10 VirtualMachineSizeTypes = "Standard_A10"
+ // StandardA11 ...
+ StandardA11 VirtualMachineSizeTypes = "Standard_A11"
+ // StandardA1V2 ...
+ StandardA1V2 VirtualMachineSizeTypes = "Standard_A1_v2"
+ // StandardA2 ...
+ StandardA2 VirtualMachineSizeTypes = "Standard_A2"
+ // StandardA2mV2 ...
+ StandardA2mV2 VirtualMachineSizeTypes = "Standard_A2m_v2"
+ // StandardA2V2 ...
+ StandardA2V2 VirtualMachineSizeTypes = "Standard_A2_v2"
+ // StandardA3 ...
+ StandardA3 VirtualMachineSizeTypes = "Standard_A3"
+ // StandardA4 ...
+ StandardA4 VirtualMachineSizeTypes = "Standard_A4"
+ // StandardA4mV2 ...
+ StandardA4mV2 VirtualMachineSizeTypes = "Standard_A4m_v2"
+ // StandardA4V2 ...
+ StandardA4V2 VirtualMachineSizeTypes = "Standard_A4_v2"
+ // StandardA5 ...
+ StandardA5 VirtualMachineSizeTypes = "Standard_A5"
+ // StandardA6 ...
+ StandardA6 VirtualMachineSizeTypes = "Standard_A6"
+ // StandardA7 ...
+ StandardA7 VirtualMachineSizeTypes = "Standard_A7"
+ // StandardA8 ...
+ StandardA8 VirtualMachineSizeTypes = "Standard_A8"
+ // StandardA8mV2 ...
+ StandardA8mV2 VirtualMachineSizeTypes = "Standard_A8m_v2"
+ // StandardA8V2 ...
+ StandardA8V2 VirtualMachineSizeTypes = "Standard_A8_v2"
+ // StandardA9 ...
+ StandardA9 VirtualMachineSizeTypes = "Standard_A9"
+ // StandardB1ms ...
+ StandardB1ms VirtualMachineSizeTypes = "Standard_B1ms"
+ // StandardB1s ...
+ StandardB1s VirtualMachineSizeTypes = "Standard_B1s"
+ // StandardB2ms ...
+ StandardB2ms VirtualMachineSizeTypes = "Standard_B2ms"
+ // StandardB2s ...
+ StandardB2s VirtualMachineSizeTypes = "Standard_B2s"
+ // StandardB4ms ...
+ StandardB4ms VirtualMachineSizeTypes = "Standard_B4ms"
+ // StandardB8ms ...
+ StandardB8ms VirtualMachineSizeTypes = "Standard_B8ms"
+ // StandardD1 ...
+ StandardD1 VirtualMachineSizeTypes = "Standard_D1"
+ // StandardD11 ...
+ StandardD11 VirtualMachineSizeTypes = "Standard_D11"
+ // StandardD11V2 ...
+ StandardD11V2 VirtualMachineSizeTypes = "Standard_D11_v2"
+ // StandardD12 ...
+ StandardD12 VirtualMachineSizeTypes = "Standard_D12"
+ // StandardD12V2 ...
+ StandardD12V2 VirtualMachineSizeTypes = "Standard_D12_v2"
+ // StandardD13 ...
+ StandardD13 VirtualMachineSizeTypes = "Standard_D13"
+ // StandardD13V2 ...
+ StandardD13V2 VirtualMachineSizeTypes = "Standard_D13_v2"
+ // StandardD14 ...
+ StandardD14 VirtualMachineSizeTypes = "Standard_D14"
+ // StandardD14V2 ...
+ StandardD14V2 VirtualMachineSizeTypes = "Standard_D14_v2"
+ // StandardD15V2 ...
+ StandardD15V2 VirtualMachineSizeTypes = "Standard_D15_v2"
+ // StandardD16sV3 ...
+ StandardD16sV3 VirtualMachineSizeTypes = "Standard_D16s_v3"
+ // StandardD16V3 ...
+ StandardD16V3 VirtualMachineSizeTypes = "Standard_D16_v3"
+ // StandardD1V2 ...
+ StandardD1V2 VirtualMachineSizeTypes = "Standard_D1_v2"
+ // StandardD2 ...
+ StandardD2 VirtualMachineSizeTypes = "Standard_D2"
+ // StandardD2sV3 ...
+ StandardD2sV3 VirtualMachineSizeTypes = "Standard_D2s_v3"
+ // StandardD2V2 ...
+ StandardD2V2 VirtualMachineSizeTypes = "Standard_D2_v2"
+ // StandardD2V3 ...
+ StandardD2V3 VirtualMachineSizeTypes = "Standard_D2_v3"
+ // StandardD3 ...
+ StandardD3 VirtualMachineSizeTypes = "Standard_D3"
+ // StandardD32sV3 ...
+ StandardD32sV3 VirtualMachineSizeTypes = "Standard_D32s_v3"
+ // StandardD32V3 ...
+ StandardD32V3 VirtualMachineSizeTypes = "Standard_D32_v3"
+ // StandardD3V2 ...
+ StandardD3V2 VirtualMachineSizeTypes = "Standard_D3_v2"
+ // StandardD4 ...
+ StandardD4 VirtualMachineSizeTypes = "Standard_D4"
+ // StandardD4sV3 ...
+ StandardD4sV3 VirtualMachineSizeTypes = "Standard_D4s_v3"
+ // StandardD4V2 ...
+ StandardD4V2 VirtualMachineSizeTypes = "Standard_D4_v2"
+ // StandardD4V3 ...
+ StandardD4V3 VirtualMachineSizeTypes = "Standard_D4_v3"
+ // StandardD5V2 ...
+ StandardD5V2 VirtualMachineSizeTypes = "Standard_D5_v2"
+ // StandardD64sV3 ...
+ StandardD64sV3 VirtualMachineSizeTypes = "Standard_D64s_v3"
+ // StandardD64V3 ...
+ StandardD64V3 VirtualMachineSizeTypes = "Standard_D64_v3"
+ // StandardD8sV3 ...
+ StandardD8sV3 VirtualMachineSizeTypes = "Standard_D8s_v3"
+ // StandardD8V3 ...
+ StandardD8V3 VirtualMachineSizeTypes = "Standard_D8_v3"
+ // StandardDS1 ...
+ StandardDS1 VirtualMachineSizeTypes = "Standard_DS1"
+ // StandardDS11 ...
+ StandardDS11 VirtualMachineSizeTypes = "Standard_DS11"
+ // StandardDS11V2 ...
+ StandardDS11V2 VirtualMachineSizeTypes = "Standard_DS11_v2"
+ // StandardDS12 ...
+ StandardDS12 VirtualMachineSizeTypes = "Standard_DS12"
+ // StandardDS12V2 ...
+ StandardDS12V2 VirtualMachineSizeTypes = "Standard_DS12_v2"
+ // StandardDS13 ...
+ StandardDS13 VirtualMachineSizeTypes = "Standard_DS13"
+ // StandardDS132V2 ...
+ StandardDS132V2 VirtualMachineSizeTypes = "Standard_DS13-2_v2"
+ // StandardDS134V2 ...
+ StandardDS134V2 VirtualMachineSizeTypes = "Standard_DS13-4_v2"
+ // StandardDS13V2 ...
+ StandardDS13V2 VirtualMachineSizeTypes = "Standard_DS13_v2"
+ // StandardDS14 ...
+ StandardDS14 VirtualMachineSizeTypes = "Standard_DS14"
+ // StandardDS144V2 ...
+ StandardDS144V2 VirtualMachineSizeTypes = "Standard_DS14-4_v2"
+ // StandardDS148V2 ...
+ StandardDS148V2 VirtualMachineSizeTypes = "Standard_DS14-8_v2"
+ // StandardDS14V2 ...
+ StandardDS14V2 VirtualMachineSizeTypes = "Standard_DS14_v2"
+ // StandardDS15V2 ...
+ StandardDS15V2 VirtualMachineSizeTypes = "Standard_DS15_v2"
+ // StandardDS1V2 ...
+ StandardDS1V2 VirtualMachineSizeTypes = "Standard_DS1_v2"
+ // StandardDS2 ...
+ StandardDS2 VirtualMachineSizeTypes = "Standard_DS2"
+ // StandardDS2V2 ...
+ StandardDS2V2 VirtualMachineSizeTypes = "Standard_DS2_v2"
+ // StandardDS3 ...
+ StandardDS3 VirtualMachineSizeTypes = "Standard_DS3"
+ // StandardDS3V2 ...
+ StandardDS3V2 VirtualMachineSizeTypes = "Standard_DS3_v2"
+ // StandardDS4 ...
+ StandardDS4 VirtualMachineSizeTypes = "Standard_DS4"
+ // StandardDS4V2 ...
+ StandardDS4V2 VirtualMachineSizeTypes = "Standard_DS4_v2"
+ // StandardDS5V2 ...
+ StandardDS5V2 VirtualMachineSizeTypes = "Standard_DS5_v2"
+ // StandardE16sV3 ...
+ StandardE16sV3 VirtualMachineSizeTypes = "Standard_E16s_v3"
+ // StandardE16V3 ...
+ StandardE16V3 VirtualMachineSizeTypes = "Standard_E16_v3"
+ // StandardE2sV3 ...
+ StandardE2sV3 VirtualMachineSizeTypes = "Standard_E2s_v3"
+ // StandardE2V3 ...
+ StandardE2V3 VirtualMachineSizeTypes = "Standard_E2_v3"
+ // StandardE3216V3 ...
+ StandardE3216V3 VirtualMachineSizeTypes = "Standard_E32-16_v3"
+ // StandardE328sV3 ...
+ StandardE328sV3 VirtualMachineSizeTypes = "Standard_E32-8s_v3"
+ // StandardE32sV3 ...
+ StandardE32sV3 VirtualMachineSizeTypes = "Standard_E32s_v3"
+ // StandardE32V3 ...
+ StandardE32V3 VirtualMachineSizeTypes = "Standard_E32_v3"
+ // StandardE4sV3 ...
+ StandardE4sV3 VirtualMachineSizeTypes = "Standard_E4s_v3"
+ // StandardE4V3 ...
+ StandardE4V3 VirtualMachineSizeTypes = "Standard_E4_v3"
+ // StandardE6416sV3 ...
+ StandardE6416sV3 VirtualMachineSizeTypes = "Standard_E64-16s_v3"
+ // StandardE6432sV3 ...
+ StandardE6432sV3 VirtualMachineSizeTypes = "Standard_E64-32s_v3"
+ // StandardE64sV3 ...
+ StandardE64sV3 VirtualMachineSizeTypes = "Standard_E64s_v3"
+ // StandardE64V3 ...
+ StandardE64V3 VirtualMachineSizeTypes = "Standard_E64_v3"
+ // StandardE8sV3 ...
+ StandardE8sV3 VirtualMachineSizeTypes = "Standard_E8s_v3"
+ // StandardE8V3 ...
+ StandardE8V3 VirtualMachineSizeTypes = "Standard_E8_v3"
+ // StandardF1 ...
+ StandardF1 VirtualMachineSizeTypes = "Standard_F1"
+ // StandardF16 ...
+ StandardF16 VirtualMachineSizeTypes = "Standard_F16"
+ // StandardF16s ...
+ StandardF16s VirtualMachineSizeTypes = "Standard_F16s"
+ // StandardF16sV2 ...
+ StandardF16sV2 VirtualMachineSizeTypes = "Standard_F16s_v2"
+ // StandardF1s ...
+ StandardF1s VirtualMachineSizeTypes = "Standard_F1s"
+ // StandardF2 ...
+ StandardF2 VirtualMachineSizeTypes = "Standard_F2"
+ // StandardF2s ...
+ StandardF2s VirtualMachineSizeTypes = "Standard_F2s"
+ // StandardF2sV2 ...
+ StandardF2sV2 VirtualMachineSizeTypes = "Standard_F2s_v2"
+ // StandardF32sV2 ...
+ StandardF32sV2 VirtualMachineSizeTypes = "Standard_F32s_v2"
+ // StandardF4 ...
+ StandardF4 VirtualMachineSizeTypes = "Standard_F4"
+ // StandardF4s ...
+ StandardF4s VirtualMachineSizeTypes = "Standard_F4s"
+ // StandardF4sV2 ...
+ StandardF4sV2 VirtualMachineSizeTypes = "Standard_F4s_v2"
+ // StandardF64sV2 ...
+ StandardF64sV2 VirtualMachineSizeTypes = "Standard_F64s_v2"
+ // StandardF72sV2 ...
+ StandardF72sV2 VirtualMachineSizeTypes = "Standard_F72s_v2"
+ // StandardF8 ...
+ StandardF8 VirtualMachineSizeTypes = "Standard_F8"
+ // StandardF8s ...
+ StandardF8s VirtualMachineSizeTypes = "Standard_F8s"
+ // StandardF8sV2 ...
+ StandardF8sV2 VirtualMachineSizeTypes = "Standard_F8s_v2"
+ // StandardG1 ...
+ StandardG1 VirtualMachineSizeTypes = "Standard_G1"
+ // StandardG2 ...
+ StandardG2 VirtualMachineSizeTypes = "Standard_G2"
+ // StandardG3 ...
+ StandardG3 VirtualMachineSizeTypes = "Standard_G3"
+ // StandardG4 ...
+ StandardG4 VirtualMachineSizeTypes = "Standard_G4"
+ // StandardG5 ...
+ StandardG5 VirtualMachineSizeTypes = "Standard_G5"
+ // StandardGS1 ...
+ StandardGS1 VirtualMachineSizeTypes = "Standard_GS1"
+ // StandardGS2 ...
+ StandardGS2 VirtualMachineSizeTypes = "Standard_GS2"
+ // StandardGS3 ...
+ StandardGS3 VirtualMachineSizeTypes = "Standard_GS3"
+ // StandardGS4 ...
+ StandardGS4 VirtualMachineSizeTypes = "Standard_GS4"
+ // StandardGS44 ...
+ StandardGS44 VirtualMachineSizeTypes = "Standard_GS4-4"
+ // StandardGS48 ...
+ StandardGS48 VirtualMachineSizeTypes = "Standard_GS4-8"
+ // StandardGS5 ...
+ StandardGS5 VirtualMachineSizeTypes = "Standard_GS5"
+ // StandardGS516 ...
+ StandardGS516 VirtualMachineSizeTypes = "Standard_GS5-16"
+ // StandardGS58 ...
+ StandardGS58 VirtualMachineSizeTypes = "Standard_GS5-8"
+ // StandardH16 ...
+ StandardH16 VirtualMachineSizeTypes = "Standard_H16"
+ // StandardH16m ...
+ StandardH16m VirtualMachineSizeTypes = "Standard_H16m"
+ // StandardH16mr ...
+ StandardH16mr VirtualMachineSizeTypes = "Standard_H16mr"
+ // StandardH16r ...
+ StandardH16r VirtualMachineSizeTypes = "Standard_H16r"
+ // StandardH8 ...
+ StandardH8 VirtualMachineSizeTypes = "Standard_H8"
+ // StandardH8m ...
+ StandardH8m VirtualMachineSizeTypes = "Standard_H8m"
+ // StandardL16s ...
+ StandardL16s VirtualMachineSizeTypes = "Standard_L16s"
+ // StandardL32s ...
+ StandardL32s VirtualMachineSizeTypes = "Standard_L32s"
+ // StandardL4s ...
+ StandardL4s VirtualMachineSizeTypes = "Standard_L4s"
+ // StandardL8s ...
+ StandardL8s VirtualMachineSizeTypes = "Standard_L8s"
+ // StandardM12832ms ...
+ StandardM12832ms VirtualMachineSizeTypes = "Standard_M128-32ms"
+ // StandardM12864ms ...
+ StandardM12864ms VirtualMachineSizeTypes = "Standard_M128-64ms"
+ // StandardM128ms ...
+ StandardM128ms VirtualMachineSizeTypes = "Standard_M128ms"
+ // StandardM128s ...
+ StandardM128s VirtualMachineSizeTypes = "Standard_M128s"
+ // StandardM6416ms ...
+ StandardM6416ms VirtualMachineSizeTypes = "Standard_M64-16ms"
+ // StandardM6432ms ...
+ StandardM6432ms VirtualMachineSizeTypes = "Standard_M64-32ms"
+ // StandardM64ms ...
+ StandardM64ms VirtualMachineSizeTypes = "Standard_M64ms"
+ // StandardM64s ...
+ StandardM64s VirtualMachineSizeTypes = "Standard_M64s"
+ // StandardNC12 ...
+ StandardNC12 VirtualMachineSizeTypes = "Standard_NC12"
+ // StandardNC12sV2 ...
+ StandardNC12sV2 VirtualMachineSizeTypes = "Standard_NC12s_v2"
+ // StandardNC12sV3 ...
+ StandardNC12sV3 VirtualMachineSizeTypes = "Standard_NC12s_v3"
+ // StandardNC24 ...
+ StandardNC24 VirtualMachineSizeTypes = "Standard_NC24"
+ // StandardNC24r ...
+ StandardNC24r VirtualMachineSizeTypes = "Standard_NC24r"
+ // StandardNC24rsV2 ...
+ StandardNC24rsV2 VirtualMachineSizeTypes = "Standard_NC24rs_v2"
+ // StandardNC24rsV3 ...
+ StandardNC24rsV3 VirtualMachineSizeTypes = "Standard_NC24rs_v3"
+ // StandardNC24sV2 ...
+ StandardNC24sV2 VirtualMachineSizeTypes = "Standard_NC24s_v2"
+ // StandardNC24sV3 ...
+ StandardNC24sV3 VirtualMachineSizeTypes = "Standard_NC24s_v3"
+ // StandardNC6 ...
+ StandardNC6 VirtualMachineSizeTypes = "Standard_NC6"
+ // StandardNC6sV2 ...
+ StandardNC6sV2 VirtualMachineSizeTypes = "Standard_NC6s_v2"
+ // StandardNC6sV3 ...
+ StandardNC6sV3 VirtualMachineSizeTypes = "Standard_NC6s_v3"
+ // StandardND12s ...
+ StandardND12s VirtualMachineSizeTypes = "Standard_ND12s"
+ // StandardND24rs ...
+ StandardND24rs VirtualMachineSizeTypes = "Standard_ND24rs"
+ // StandardND24s ...
+ StandardND24s VirtualMachineSizeTypes = "Standard_ND24s"
+ // StandardND6s ...
+ StandardND6s VirtualMachineSizeTypes = "Standard_ND6s"
+ // StandardNV12 ...
+ StandardNV12 VirtualMachineSizeTypes = "Standard_NV12"
+ // StandardNV24 ...
+ StandardNV24 VirtualMachineSizeTypes = "Standard_NV24"
+ // StandardNV6 ...
+ StandardNV6 VirtualMachineSizeTypes = "Standard_NV6"
+)
+
+// PossibleVirtualMachineSizeTypesValues returns an array of possible values for the VirtualMachineSizeTypes const type.
+func PossibleVirtualMachineSizeTypesValues() []VirtualMachineSizeTypes {
+ return []VirtualMachineSizeTypes{BasicA0, BasicA1, BasicA2, BasicA3, BasicA4, StandardA0, StandardA1, StandardA10, StandardA11, StandardA1V2, StandardA2, StandardA2mV2, StandardA2V2, StandardA3, StandardA4, StandardA4mV2, StandardA4V2, StandardA5, StandardA6, StandardA7, StandardA8, StandardA8mV2, StandardA8V2, StandardA9, StandardB1ms, StandardB1s, StandardB2ms, StandardB2s, StandardB4ms, StandardB8ms, StandardD1, StandardD11, StandardD11V2, StandardD12, StandardD12V2, StandardD13, StandardD13V2, StandardD14, StandardD14V2, StandardD15V2, StandardD16sV3, StandardD16V3, StandardD1V2, StandardD2, StandardD2sV3, StandardD2V2, StandardD2V3, StandardD3, StandardD32sV3, StandardD32V3, StandardD3V2, StandardD4, StandardD4sV3, StandardD4V2, StandardD4V3, StandardD5V2, StandardD64sV3, StandardD64V3, StandardD8sV3, StandardD8V3, StandardDS1, StandardDS11, StandardDS11V2, StandardDS12, StandardDS12V2, StandardDS13, StandardDS132V2, StandardDS134V2, StandardDS13V2, StandardDS14, StandardDS144V2, StandardDS148V2, StandardDS14V2, StandardDS15V2, StandardDS1V2, StandardDS2, StandardDS2V2, StandardDS3, StandardDS3V2, StandardDS4, StandardDS4V2, StandardDS5V2, StandardE16sV3, StandardE16V3, StandardE2sV3, StandardE2V3, StandardE3216V3, StandardE328sV3, StandardE32sV3, StandardE32V3, StandardE4sV3, StandardE4V3, StandardE6416sV3, StandardE6432sV3, StandardE64sV3, StandardE64V3, StandardE8sV3, StandardE8V3, StandardF1, StandardF16, StandardF16s, StandardF16sV2, StandardF1s, StandardF2, StandardF2s, StandardF2sV2, StandardF32sV2, StandardF4, StandardF4s, StandardF4sV2, StandardF64sV2, StandardF72sV2, StandardF8, StandardF8s, StandardF8sV2, StandardG1, StandardG2, StandardG3, StandardG4, StandardG5, StandardGS1, StandardGS2, StandardGS3, StandardGS4, StandardGS44, StandardGS48, StandardGS5, StandardGS516, StandardGS58, StandardH16, StandardH16m, StandardH16mr, StandardH16r, StandardH8, StandardH8m, StandardL16s, StandardL32s, StandardL4s, StandardL8s, StandardM12832ms, StandardM12864ms, StandardM128ms, StandardM128s, StandardM6416ms, StandardM6432ms, StandardM64ms, StandardM64s, StandardNC12, StandardNC12sV2, StandardNC12sV3, StandardNC24, StandardNC24r, StandardNC24rsV2, StandardNC24rsV3, StandardNC24sV2, StandardNC24sV3, StandardNC6, StandardNC6sV2, StandardNC6sV3, StandardND12s, StandardND24rs, StandardND24s, StandardND6s, StandardNV12, StandardNV24, StandardNV6}
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/images.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/images.go
new file mode 100644
index 00000000000..3fcf899baf0
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/images.go
@@ -0,0 +1,661 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ImagesClient is the compute Client
+type ImagesClient struct {
+ BaseClient
+}
+
+// NewImagesClient creates an instance of the ImagesClient client.
+func NewImagesClient(subscriptionID string) ImagesClient {
+ return NewImagesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewImagesClientWithBaseURI creates an instance of the ImagesClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewImagesClientWithBaseURI(baseURI string, subscriptionID string) ImagesClient {
+ return ImagesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or update an image.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// imageName - the name of the image.
+// parameters - parameters supplied to the Create Image operation.
+func (client ImagesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, imageName string, parameters Image) (result ImagesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, imageName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client ImagesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, imageName string, parameters Image) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "imageName": autorest.Encode("path", imageName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/images/{imageName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ImagesClient) CreateOrUpdateSender(req *http.Request) (future ImagesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ImagesClient) (i Image, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.ImagesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ i.Response.Response, err = future.GetResult(sender)
+ if i.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && i.Response.Response.StatusCode != http.StatusNoContent {
+ i, err = client.CreateOrUpdateResponder(i.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesCreateOrUpdateFuture", "Result", i.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client ImagesClient) CreateOrUpdateResponder(resp *http.Response) (result Image, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes an Image.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// imageName - the name of the image.
+func (client ImagesClient) Delete(ctx context.Context, resourceGroupName string, imageName string) (result ImagesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, imageName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client ImagesClient) DeletePreparer(ctx context.Context, resourceGroupName string, imageName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "imageName": autorest.Encode("path", imageName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/images/{imageName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client ImagesClient) DeleteSender(req *http.Request) (future ImagesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ImagesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.ImagesDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client ImagesClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get gets an image.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// imageName - the name of the image.
+// expand - the expand expression to apply on the operation.
+func (client ImagesClient) Get(ctx context.Context, resourceGroupName string, imageName string, expand string) (result Image, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, imageName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client ImagesClient) GetPreparer(ctx context.Context, resourceGroupName string, imageName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "imageName": autorest.Encode("path", imageName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/images/{imageName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client ImagesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client ImagesClient) GetResponder(resp *http.Response) (result Image, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets the list of Images in the subscription. Use nextLink property in the response to get the next page of
+// Images. Do this till nextLink is null to fetch all the Images.
+func (client ImagesClient) List(ctx context.Context) (result ImageListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.List")
+ defer func() {
+ sc := -1
+ if result.ilr.Response.Response != nil {
+ sc = result.ilr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.ilr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.ilr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.ilr.hasNextLink() && result.ilr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ImagesClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/images", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ImagesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ImagesClient) ListResponder(resp *http.Response) (result ImageListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ImagesClient) listNextResults(ctx context.Context, lastResults ImageListResult) (result ImageListResult, err error) {
+ req, err := lastResults.imageListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.ImagesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.ImagesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ImagesClient) ListComplete(ctx context.Context) (result ImageListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
+
+// ListByResourceGroup gets the list of images under a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client ImagesClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ImageListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.ilr.Response.Response != nil {
+ sc = result.ilr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listByResourceGroupNextResults
+ req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.ilr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result.ilr, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "ListByResourceGroup", resp, "Failure responding to request")
+ return
+ }
+ if result.ilr.hasNextLink() && result.ilr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client ImagesClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/images", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client ImagesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client ImagesClient) ListByResourceGroupResponder(resp *http.Response) (result ImageListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByResourceGroupNextResults retrieves the next set of results, if any.
+func (client ImagesClient) listByResourceGroupNextResults(ctx context.Context, lastResults ImageListResult) (result ImageListResult, err error) {
+ req, err := lastResults.imageListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.ImagesClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.ImagesClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ImagesClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ImageListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
+ return
+}
+
+// Update update an image.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// imageName - the name of the image.
+// parameters - parameters supplied to the Update Image operation.
+func (client ImagesClient) Update(ctx context.Context, resourceGroupName string, imageName string, parameters ImageUpdate) (result ImagesUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImagesClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, imageName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client ImagesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, imageName string, parameters ImageUpdate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "imageName": autorest.Encode("path", imageName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/images/{imageName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client ImagesClient) UpdateSender(req *http.Request) (future ImagesUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ImagesClient) (i Image, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.ImagesUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ i.Response.Response, err = future.GetResult(sender)
+ if i.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && i.Response.Response.StatusCode != http.StatusNoContent {
+ i, err = client.UpdateResponder(i.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ImagesUpdateFuture", "Result", i.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client ImagesClient) UpdateResponder(resp *http.Response) (result Image, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/loganalytics.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/loganalytics.go
new file mode 100644
index 00000000000..461a0b1210b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/loganalytics.go
@@ -0,0 +1,261 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LogAnalyticsClient is the compute Client
+type LogAnalyticsClient struct {
+ BaseClient
+}
+
+// NewLogAnalyticsClient creates an instance of the LogAnalyticsClient client.
+func NewLogAnalyticsClient(subscriptionID string) LogAnalyticsClient {
+ return NewLogAnalyticsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLogAnalyticsClientWithBaseURI creates an instance of the LogAnalyticsClient client using a custom endpoint. Use
+// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewLogAnalyticsClientWithBaseURI(baseURI string, subscriptionID string) LogAnalyticsClient {
+ return LogAnalyticsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// ExportRequestRateByInterval export logs that show Api requests made by this subscription in the given time window to
+// show throttling activities.
+// Parameters:
+// parameters - parameters supplied to the LogAnalytics getRequestRateByInterval Api.
+// location - the location upon which virtual-machine-sizes is queried.
+func (client LogAnalyticsClient) ExportRequestRateByInterval(ctx context.Context, parameters RequestRateByIntervalInput, location string) (result LogAnalyticsExportRequestRateByIntervalFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LogAnalyticsClient.ExportRequestRateByInterval")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.LogAnalyticsClient", "ExportRequestRateByInterval", err.Error())
+ }
+
+ req, err := client.ExportRequestRateByIntervalPreparer(ctx, parameters, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsClient", "ExportRequestRateByInterval", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ExportRequestRateByIntervalSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsClient", "ExportRequestRateByInterval", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ExportRequestRateByIntervalPreparer prepares the ExportRequestRateByInterval request.
+func (client LogAnalyticsClient) ExportRequestRateByIntervalPreparer(ctx context.Context, parameters RequestRateByIntervalInput, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/logAnalytics/apiAccess/getRequestRateByInterval", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ExportRequestRateByIntervalSender sends the ExportRequestRateByInterval request. The method will close the
+// http.Response Body if it receives an error.
+func (client LogAnalyticsClient) ExportRequestRateByIntervalSender(req *http.Request) (future LogAnalyticsExportRequestRateByIntervalFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LogAnalyticsClient) (laor LogAnalyticsOperationResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsExportRequestRateByIntervalFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.LogAnalyticsExportRequestRateByIntervalFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ laor.Response.Response, err = future.GetResult(sender)
+ if laor.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsExportRequestRateByIntervalFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && laor.Response.Response.StatusCode != http.StatusNoContent {
+ laor, err = client.ExportRequestRateByIntervalResponder(laor.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsExportRequestRateByIntervalFuture", "Result", laor.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ExportRequestRateByIntervalResponder handles the response to the ExportRequestRateByInterval request. The method always
+// closes the http.Response Body.
+func (client LogAnalyticsClient) ExportRequestRateByIntervalResponder(resp *http.Response) (result LogAnalyticsOperationResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ExportThrottledRequests export logs that show total throttled Api requests for this subscription in the given time
+// window.
+// Parameters:
+// parameters - parameters supplied to the LogAnalytics getThrottledRequests Api.
+// location - the location upon which virtual-machine-sizes is queried.
+func (client LogAnalyticsClient) ExportThrottledRequests(ctx context.Context, parameters ThrottledRequestsInput, location string) (result LogAnalyticsExportThrottledRequestsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LogAnalyticsClient.ExportThrottledRequests")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.LogAnalyticsClient", "ExportThrottledRequests", err.Error())
+ }
+
+ req, err := client.ExportThrottledRequestsPreparer(ctx, parameters, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsClient", "ExportThrottledRequests", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ExportThrottledRequestsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsClient", "ExportThrottledRequests", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ExportThrottledRequestsPreparer prepares the ExportThrottledRequests request.
+func (client LogAnalyticsClient) ExportThrottledRequestsPreparer(ctx context.Context, parameters ThrottledRequestsInput, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/logAnalytics/apiAccess/getThrottledRequests", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ExportThrottledRequestsSender sends the ExportThrottledRequests request. The method will close the
+// http.Response Body if it receives an error.
+func (client LogAnalyticsClient) ExportThrottledRequestsSender(req *http.Request) (future LogAnalyticsExportThrottledRequestsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LogAnalyticsClient) (laor LogAnalyticsOperationResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsExportThrottledRequestsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.LogAnalyticsExportThrottledRequestsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ laor.Response.Response, err = future.GetResult(sender)
+ if laor.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsExportThrottledRequestsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && laor.Response.Response.StatusCode != http.StatusNoContent {
+ laor, err = client.ExportThrottledRequestsResponder(laor.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.LogAnalyticsExportThrottledRequestsFuture", "Result", laor.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ExportThrottledRequestsResponder handles the response to the ExportThrottledRequests request. The method always
+// closes the http.Response Body.
+func (client LogAnalyticsClient) ExportThrottledRequestsResponder(resp *http.Response) (result LogAnalyticsOperationResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/models.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/models.go
new file mode 100644
index 00000000000..44e261dd296
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/models.go
@@ -0,0 +1,7403 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "encoding/json"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/date"
+ "github.com/Azure/go-autorest/autorest/to"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// The package's fully qualified name.
+const fqdn = "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute"
+
+// AccessURI a disk access SAS uri.
+type AccessURI struct {
+ autorest.Response `json:"-"`
+ // AccessURIOutput - Operation output data (raw JSON)
+ *AccessURIOutput `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for AccessURI.
+func (au AccessURI) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if au.AccessURIOutput != nil {
+ objectMap["properties"] = au.AccessURIOutput
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for AccessURI struct.
+func (au *AccessURI) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var accessURIOutput AccessURIOutput
+ err = json.Unmarshal(*v, &accessURIOutput)
+ if err != nil {
+ return err
+ }
+ au.AccessURIOutput = &accessURIOutput
+ }
+ }
+ }
+
+ return nil
+}
+
+// AccessURIOutput azure properties, including output.
+type AccessURIOutput struct {
+ // AccessURIRaw - Operation output data (raw JSON)
+ *AccessURIRaw `json:"output,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for AccessURIOutput.
+func (auo AccessURIOutput) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if auo.AccessURIRaw != nil {
+ objectMap["output"] = auo.AccessURIRaw
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for AccessURIOutput struct.
+func (auo *AccessURIOutput) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "output":
+ if v != nil {
+ var accessURIRaw AccessURIRaw
+ err = json.Unmarshal(*v, &accessURIRaw)
+ if err != nil {
+ return err
+ }
+ auo.AccessURIRaw = &accessURIRaw
+ }
+ }
+ }
+
+ return nil
+}
+
+// AccessURIRaw this object gets 'bubbled up' through flattening.
+type AccessURIRaw struct {
+ // AccessSAS - READ-ONLY; A SAS uri for accessing a disk.
+ AccessSAS *string `json:"accessSAS,omitempty"`
+}
+
+// AdditionalUnattendContent specifies additional XML formatted information that can be included in the
+// Unattend.xml file, which is used by Windows Setup. Contents are defined by setting name, component name,
+// and the pass in which the content is applied.
+type AdditionalUnattendContent struct {
+ // PassName - The pass name. Currently, the only allowable value is OobeSystem. Possible values include: 'OobeSystem'
+ PassName PassNames `json:"passName,omitempty"`
+ // ComponentName - The component name. Currently, the only allowable value is Microsoft-Windows-Shell-Setup. Possible values include: 'MicrosoftWindowsShellSetup'
+ ComponentName ComponentNames `json:"componentName,omitempty"`
+ // SettingName - Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon. Possible values include: 'AutoLogon', 'FirstLogonCommands'
+ SettingName SettingNames `json:"settingName,omitempty"`
+ // Content - Specifies the XML formatted content that is added to the unattend.xml file for the specified path and component. The XML must be less than 4KB and must include the root element for the setting or feature that is being inserted.
+ Content *string `json:"content,omitempty"`
+}
+
+// APIEntityReference the API entity reference.
+type APIEntityReference struct {
+ // ID - The ARM resource id in the form of /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/...
+ ID *string `json:"id,omitempty"`
+}
+
+// APIError api error.
+type APIError struct {
+ // Details - The Api error details
+ Details *[]APIErrorBase `json:"details,omitempty"`
+ // Innererror - The Api inner error
+ Innererror *InnerError `json:"innererror,omitempty"`
+ // Code - The error code.
+ Code *string `json:"code,omitempty"`
+ // Target - The target of the particular error.
+ Target *string `json:"target,omitempty"`
+ // Message - The error message.
+ Message *string `json:"message,omitempty"`
+}
+
+// APIErrorBase api error base.
+type APIErrorBase struct {
+ // Code - The error code.
+ Code *string `json:"code,omitempty"`
+ // Target - The target of the particular error.
+ Target *string `json:"target,omitempty"`
+ // Message - The error message.
+ Message *string `json:"message,omitempty"`
+}
+
+// AutoOSUpgradePolicy the configuration parameters used for performing automatic OS upgrade.
+type AutoOSUpgradePolicy struct {
+ // DisableAutoRollback - Whether OS image rollback feature should be disabled. Default value is false.
+ DisableAutoRollback *bool `json:"disableAutoRollback,omitempty"`
+}
+
+// AvailabilitySet specifies information about the availability set that the virtual machine should be
+// assigned to. Virtual machines specified in the same availability set are allocated to different nodes to
+// maximize availability. For more information about availability sets, see [Manage the availability of
+// virtual
+// machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-manage-availability?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+//
For more information on Azure planned maintenance, see [Planned maintenance for virtual
+// machines in
+// Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-planned-maintenance?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
+//
Currently, a VM can only be added to availability set at creation time. An existing VM cannot
+// be added to an availability set.
+type AvailabilitySet struct {
+ autorest.Response `json:"-"`
+ *AvailabilitySetProperties `json:"properties,omitempty"`
+ // Sku - Sku of the availability set
+ Sku *Sku `json:"sku,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for AvailabilitySet.
+func (as AvailabilitySet) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if as.AvailabilitySetProperties != nil {
+ objectMap["properties"] = as.AvailabilitySetProperties
+ }
+ if as.Sku != nil {
+ objectMap["sku"] = as.Sku
+ }
+ if as.Location != nil {
+ objectMap["location"] = as.Location
+ }
+ if as.Tags != nil {
+ objectMap["tags"] = as.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for AvailabilitySet struct.
+func (as *AvailabilitySet) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var availabilitySetProperties AvailabilitySetProperties
+ err = json.Unmarshal(*v, &availabilitySetProperties)
+ if err != nil {
+ return err
+ }
+ as.AvailabilitySetProperties = &availabilitySetProperties
+ }
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ as.Sku = &sku
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ as.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ as.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ as.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ as.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ as.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// AvailabilitySetListResult the List Availability Set operation response.
+type AvailabilitySetListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of availability sets
+ Value *[]AvailabilitySet `json:"value,omitempty"`
+ // NextLink - The URI to fetch the next page of AvailabilitySets. Call ListNext() with this URI to fetch the next page of AvailabilitySets.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AvailabilitySetListResultIterator provides access to a complete listing of AvailabilitySet values.
+type AvailabilitySetListResultIterator struct {
+ i int
+ page AvailabilitySetListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *AvailabilitySetListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *AvailabilitySetListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter AvailabilitySetListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter AvailabilitySetListResultIterator) Response() AvailabilitySetListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter AvailabilitySetListResultIterator) Value() AvailabilitySet {
+ if !iter.page.NotDone() {
+ return AvailabilitySet{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the AvailabilitySetListResultIterator type.
+func NewAvailabilitySetListResultIterator(page AvailabilitySetListResultPage) AvailabilitySetListResultIterator {
+ return AvailabilitySetListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (aslr AvailabilitySetListResult) IsEmpty() bool {
+ return aslr.Value == nil || len(*aslr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (aslr AvailabilitySetListResult) hasNextLink() bool {
+ return aslr.NextLink != nil && len(*aslr.NextLink) != 0
+}
+
+// availabilitySetListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (aslr AvailabilitySetListResult) availabilitySetListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !aslr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(aslr.NextLink)))
+}
+
+// AvailabilitySetListResultPage contains a page of AvailabilitySet values.
+type AvailabilitySetListResultPage struct {
+ fn func(context.Context, AvailabilitySetListResult) (AvailabilitySetListResult, error)
+ aslr AvailabilitySetListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *AvailabilitySetListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailabilitySetListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.aslr)
+ if err != nil {
+ return err
+ }
+ page.aslr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *AvailabilitySetListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page AvailabilitySetListResultPage) NotDone() bool {
+ return !page.aslr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page AvailabilitySetListResultPage) Response() AvailabilitySetListResult {
+ return page.aslr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page AvailabilitySetListResultPage) Values() []AvailabilitySet {
+ if page.aslr.IsEmpty() {
+ return nil
+ }
+ return *page.aslr.Value
+}
+
+// Creates a new instance of the AvailabilitySetListResultPage type.
+func NewAvailabilitySetListResultPage(cur AvailabilitySetListResult, getNextPage func(context.Context, AvailabilitySetListResult) (AvailabilitySetListResult, error)) AvailabilitySetListResultPage {
+ return AvailabilitySetListResultPage{
+ fn: getNextPage,
+ aslr: cur,
+ }
+}
+
+// AvailabilitySetProperties the instance view of a resource.
+type AvailabilitySetProperties struct {
+ // PlatformUpdateDomainCount - Update Domain count.
+ PlatformUpdateDomainCount *int32 `json:"platformUpdateDomainCount,omitempty"`
+ // PlatformFaultDomainCount - Fault Domain count.
+ PlatformFaultDomainCount *int32 `json:"platformFaultDomainCount,omitempty"`
+ // VirtualMachines - A list of references to all virtual machines in the availability set.
+ VirtualMachines *[]SubResource `json:"virtualMachines,omitempty"`
+ // Statuses - READ-ONLY; The resource status information.
+ Statuses *[]InstanceViewStatus `json:"statuses,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for AvailabilitySetProperties.
+func (asp AvailabilitySetProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if asp.PlatformUpdateDomainCount != nil {
+ objectMap["platformUpdateDomainCount"] = asp.PlatformUpdateDomainCount
+ }
+ if asp.PlatformFaultDomainCount != nil {
+ objectMap["platformFaultDomainCount"] = asp.PlatformFaultDomainCount
+ }
+ if asp.VirtualMachines != nil {
+ objectMap["virtualMachines"] = asp.VirtualMachines
+ }
+ return json.Marshal(objectMap)
+}
+
+// AvailabilitySetUpdate specifies information about the availability set that the virtual machine should
+// be assigned to. Only tags may be updated.
+type AvailabilitySetUpdate struct {
+ *AvailabilitySetProperties `json:"properties,omitempty"`
+ // Sku - Sku of the availability set
+ Sku *Sku `json:"sku,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for AvailabilitySetUpdate.
+func (asu AvailabilitySetUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if asu.AvailabilitySetProperties != nil {
+ objectMap["properties"] = asu.AvailabilitySetProperties
+ }
+ if asu.Sku != nil {
+ objectMap["sku"] = asu.Sku
+ }
+ if asu.Tags != nil {
+ objectMap["tags"] = asu.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for AvailabilitySetUpdate struct.
+func (asu *AvailabilitySetUpdate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var availabilitySetProperties AvailabilitySetProperties
+ err = json.Unmarshal(*v, &availabilitySetProperties)
+ if err != nil {
+ return err
+ }
+ asu.AvailabilitySetProperties = &availabilitySetProperties
+ }
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ asu.Sku = &sku
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ asu.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// BootDiagnostics boot Diagnostics is a debugging feature which allows you to view Console Output and
+// Screenshot to diagnose VM status.
You can easily view the output of your console log.
+// Azure also enables you to see a screenshot of the VM from the hypervisor.
+type BootDiagnostics struct {
+ // Enabled - Whether boot diagnostics should be enabled on the Virtual Machine.
+ Enabled *bool `json:"enabled,omitempty"`
+ // StorageURI - Uri of the storage account to use for placing the console output and screenshot.
+ StorageURI *string `json:"storageUri,omitempty"`
+}
+
+// BootDiagnosticsInstanceView the instance view of a virtual machine boot diagnostics.
+type BootDiagnosticsInstanceView struct {
+ // ConsoleScreenshotBlobURI - READ-ONLY; The console screenshot blob URI.
+ ConsoleScreenshotBlobURI *string `json:"consoleScreenshotBlobUri,omitempty"`
+ // SerialConsoleLogBlobURI - READ-ONLY; The Linux serial console log blob Uri.
+ SerialConsoleLogBlobURI *string `json:"serialConsoleLogBlobUri,omitempty"`
+}
+
+// CreationData data used when creating a disk.
+type CreationData struct {
+ // CreateOption - This enumerates the possible sources of a disk's creation. Possible values include: 'Empty', 'Attach', 'FromImage', 'Import', 'Copy'
+ CreateOption DiskCreateOption `json:"createOption,omitempty"`
+ // StorageAccountID - If createOption is Import, the Azure Resource Manager identifier of the storage account containing the blob to import as a disk. Required only if the blob is in a different subscription
+ StorageAccountID *string `json:"storageAccountId,omitempty"`
+ // ImageReference - Disk source information.
+ ImageReference *ImageDiskReference `json:"imageReference,omitempty"`
+ // SourceURI - If createOption is Import, this is the URI of a blob to be imported into a managed disk.
+ SourceURI *string `json:"sourceUri,omitempty"`
+ // SourceResourceID - If createOption is Copy, this is the ARM id of the source snapshot or disk.
+ SourceResourceID *string `json:"sourceResourceId,omitempty"`
+}
+
+// DataDisk describes a data disk.
+type DataDisk struct {
+ // Lun - Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
+ Lun *int32 `json:"lun,omitempty"`
+ // Name - The disk name.
+ Name *string `json:"name,omitempty"`
+ // Vhd - The virtual hard disk.
+ Vhd *VirtualHardDisk `json:"vhd,omitempty"`
+ // Image - The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
+ Image *VirtualHardDisk `json:"image,omitempty"`
+ // Caching - Specifies the caching requirements.
Possible values are:
**None**
**ReadOnly**
**ReadWrite**
Default: **None for Standard storage. ReadOnly for Premium storage**. Possible values include: 'CachingTypesNone', 'CachingTypesReadOnly', 'CachingTypesReadWrite'
+ Caching CachingTypes `json:"caching,omitempty"`
+ // WriteAcceleratorEnabled - Specifies whether writeAccelerator should be enabled or disabled on the disk.
+ WriteAcceleratorEnabled *bool `json:"writeAcceleratorEnabled,omitempty"`
+ // CreateOption - Specifies how the virtual machine should be created.
Possible values are:
**Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.
**FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described. Possible values include: 'DiskCreateOptionTypesFromImage', 'DiskCreateOptionTypesEmpty', 'DiskCreateOptionTypesAttach'
+ CreateOption DiskCreateOptionTypes `json:"createOption,omitempty"`
+ // DiskSizeGB - Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image.
This value cannot be larger than 1023 GB
+ DiskSizeGB *int32 `json:"diskSizeGB,omitempty"`
+ // ManagedDisk - The managed disk parameters.
+ ManagedDisk *ManagedDiskParameters `json:"managedDisk,omitempty"`
+}
+
+// DataDiskImage contains the data disk images information.
+type DataDiskImage struct {
+ // Lun - READ-ONLY; Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
+ Lun *int32 `json:"lun,omitempty"`
+}
+
+// DiagnosticsProfile specifies the boot diagnostic settings state.
Minimum api-version:
+// 2015-06-15.
+type DiagnosticsProfile struct {
+ // BootDiagnostics - Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status.
You can easily view the output of your console log.
Azure also enables you to see a screenshot of the VM from the hypervisor.
+ BootDiagnostics *BootDiagnostics `json:"bootDiagnostics,omitempty"`
+}
+
+// Disk disk resource.
+type Disk struct {
+ autorest.Response `json:"-"`
+ // ManagedBy - READ-ONLY; A relative URI containing the ID of the VM that has the disk attached.
+ ManagedBy *string `json:"managedBy,omitempty"`
+ Sku *DiskSku `json:"sku,omitempty"`
+ // Zones - The Logical zone list for Disk.
+ Zones *[]string `json:"zones,omitempty"`
+ *DiskProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Disk.
+func (d Disk) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if d.Sku != nil {
+ objectMap["sku"] = d.Sku
+ }
+ if d.Zones != nil {
+ objectMap["zones"] = d.Zones
+ }
+ if d.DiskProperties != nil {
+ objectMap["properties"] = d.DiskProperties
+ }
+ if d.Location != nil {
+ objectMap["location"] = d.Location
+ }
+ if d.Tags != nil {
+ objectMap["tags"] = d.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Disk struct.
+func (d *Disk) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "managedBy":
+ if v != nil {
+ var managedBy string
+ err = json.Unmarshal(*v, &managedBy)
+ if err != nil {
+ return err
+ }
+ d.ManagedBy = &managedBy
+ }
+ case "sku":
+ if v != nil {
+ var sku DiskSku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ d.Sku = &sku
+ }
+ case "zones":
+ if v != nil {
+ var zones []string
+ err = json.Unmarshal(*v, &zones)
+ if err != nil {
+ return err
+ }
+ d.Zones = &zones
+ }
+ case "properties":
+ if v != nil {
+ var diskProperties DiskProperties
+ err = json.Unmarshal(*v, &diskProperties)
+ if err != nil {
+ return err
+ }
+ d.DiskProperties = &diskProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ d.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ d.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ d.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ d.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ d.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// DiskEncryptionSettings describes a Encryption Settings for a Disk
+type DiskEncryptionSettings struct {
+ // DiskEncryptionKey - Specifies the location of the disk encryption key, which is a Key Vault Secret.
+ DiskEncryptionKey *KeyVaultSecretReference `json:"diskEncryptionKey,omitempty"`
+ // KeyEncryptionKey - Specifies the location of the key encryption key in Key Vault.
+ KeyEncryptionKey *KeyVaultKeyReference `json:"keyEncryptionKey,omitempty"`
+ // Enabled - Specifies whether disk encryption should be enabled on the virtual machine.
+ Enabled *bool `json:"enabled,omitempty"`
+}
+
+// DiskInstanceView the instance view of the disk.
+type DiskInstanceView struct {
+ // Name - The disk name.
+ Name *string `json:"name,omitempty"`
+ // EncryptionSettings - Specifies the encryption settings for the OS Disk.
Minimum api-version: 2015-06-15
+ EncryptionSettings *[]DiskEncryptionSettings `json:"encryptionSettings,omitempty"`
+ // Statuses - The resource status information.
+ Statuses *[]InstanceViewStatus `json:"statuses,omitempty"`
+}
+
+// DiskList the List Disks operation response.
+type DiskList struct {
+ autorest.Response `json:"-"`
+ // Value - A list of disks.
+ Value *[]Disk `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of disks. Call ListNext() with this to fetch the next page of disks.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// DiskListIterator provides access to a complete listing of Disk values.
+type DiskListIterator struct {
+ i int
+ page DiskListPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *DiskListIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DiskListIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *DiskListIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter DiskListIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter DiskListIterator) Response() DiskList {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter DiskListIterator) Value() Disk {
+ if !iter.page.NotDone() {
+ return Disk{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the DiskListIterator type.
+func NewDiskListIterator(page DiskListPage) DiskListIterator {
+ return DiskListIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (dl DiskList) IsEmpty() bool {
+ return dl.Value == nil || len(*dl.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (dl DiskList) hasNextLink() bool {
+ return dl.NextLink != nil && len(*dl.NextLink) != 0
+}
+
+// diskListPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (dl DiskList) diskListPreparer(ctx context.Context) (*http.Request, error) {
+ if !dl.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(dl.NextLink)))
+}
+
+// DiskListPage contains a page of Disk values.
+type DiskListPage struct {
+ fn func(context.Context, DiskList) (DiskList, error)
+ dl DiskList
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *DiskListPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DiskListPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.dl)
+ if err != nil {
+ return err
+ }
+ page.dl = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *DiskListPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page DiskListPage) NotDone() bool {
+ return !page.dl.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page DiskListPage) Response() DiskList {
+ return page.dl
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page DiskListPage) Values() []Disk {
+ if page.dl.IsEmpty() {
+ return nil
+ }
+ return *page.dl.Value
+}
+
+// Creates a new instance of the DiskListPage type.
+func NewDiskListPage(cur DiskList, getNextPage func(context.Context, DiskList) (DiskList, error)) DiskListPage {
+ return DiskListPage{
+ fn: getNextPage,
+ dl: cur,
+ }
+}
+
+// DiskProperties disk resource properties.
+type DiskProperties struct {
+ // TimeCreated - READ-ONLY; The time when the disk was created.
+ TimeCreated *date.Time `json:"timeCreated,omitempty"`
+ // OsType - The Operating System type. Possible values include: 'Windows', 'Linux'
+ OsType OperatingSystemTypes `json:"osType,omitempty"`
+ // CreationData - Disk source information. CreationData information cannot be changed after the disk has been created.
+ CreationData *CreationData `json:"creationData,omitempty"`
+ // DiskSizeGB - If creationData.createOption is Empty, this field is mandatory and it indicates the size of the VHD to create. If this field is present for updates or creation with other options, it indicates a resize. Resizes are only allowed if the disk is not attached to a running VM, and can only increase the disk's size.
+ DiskSizeGB *int32 `json:"diskSizeGB,omitempty"`
+ // EncryptionSettings - Encryption settings for disk or snapshot
+ EncryptionSettings *EncryptionSettings `json:"encryptionSettings,omitempty"`
+ // ProvisioningState - READ-ONLY; The disk provisioning state.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for DiskProperties.
+func (dp DiskProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if dp.OsType != "" {
+ objectMap["osType"] = dp.OsType
+ }
+ if dp.CreationData != nil {
+ objectMap["creationData"] = dp.CreationData
+ }
+ if dp.DiskSizeGB != nil {
+ objectMap["diskSizeGB"] = dp.DiskSizeGB
+ }
+ if dp.EncryptionSettings != nil {
+ objectMap["encryptionSettings"] = dp.EncryptionSettings
+ }
+ return json.Marshal(objectMap)
+}
+
+// DisksCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type DisksCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(DisksClient) (Disk, error)
+}
+
+// DisksDeleteFuture an abstraction for monitoring and retrieving the results of a long-running operation.
+type DisksDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(DisksClient) (OperationStatusResponse, error)
+}
+
+// DisksGrantAccessFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type DisksGrantAccessFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(DisksClient) (AccessURI, error)
+}
+
+// DiskSku the disks and snapshots sku name. Can be Standard_LRS or Premium_LRS.
+type DiskSku struct {
+ // Name - The sku name. Possible values include: 'StandardLRS', 'PremiumLRS'
+ Name StorageAccountTypes `json:"name,omitempty"`
+ // Tier - READ-ONLY; The sku tier.
+ Tier *string `json:"tier,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for DiskSku.
+func (ds DiskSku) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ds.Name != "" {
+ objectMap["name"] = ds.Name
+ }
+ return json.Marshal(objectMap)
+}
+
+// DisksRevokeAccessFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type DisksRevokeAccessFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(DisksClient) (OperationStatusResponse, error)
+}
+
+// DisksUpdateFuture an abstraction for monitoring and retrieving the results of a long-running operation.
+type DisksUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(DisksClient) (Disk, error)
+}
+
+// DiskUpdate disk update resource.
+type DiskUpdate struct {
+ *DiskUpdateProperties `json:"properties,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+ Sku *DiskSku `json:"sku,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for DiskUpdate.
+func (du DiskUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if du.DiskUpdateProperties != nil {
+ objectMap["properties"] = du.DiskUpdateProperties
+ }
+ if du.Tags != nil {
+ objectMap["tags"] = du.Tags
+ }
+ if du.Sku != nil {
+ objectMap["sku"] = du.Sku
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for DiskUpdate struct.
+func (du *DiskUpdate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var diskUpdateProperties DiskUpdateProperties
+ err = json.Unmarshal(*v, &diskUpdateProperties)
+ if err != nil {
+ return err
+ }
+ du.DiskUpdateProperties = &diskUpdateProperties
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ du.Tags = tags
+ }
+ case "sku":
+ if v != nil {
+ var sku DiskSku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ du.Sku = &sku
+ }
+ }
+ }
+
+ return nil
+}
+
+// DiskUpdateProperties disk resource update properties.
+type DiskUpdateProperties struct {
+ // OsType - the Operating System type. Possible values include: 'Windows', 'Linux'
+ OsType OperatingSystemTypes `json:"osType,omitempty"`
+ // DiskSizeGB - If creationData.createOption is Empty, this field is mandatory and it indicates the size of the VHD to create. If this field is present for updates or creation with other options, it indicates a resize. Resizes are only allowed if the disk is not attached to a running VM, and can only increase the disk's size.
+ DiskSizeGB *int32 `json:"diskSizeGB,omitempty"`
+ // EncryptionSettings - Encryption settings for disk or snapshot
+ EncryptionSettings *EncryptionSettings `json:"encryptionSettings,omitempty"`
+}
+
+// EncryptionSettings encryption settings for disk or snapshot
+type EncryptionSettings struct {
+ // Enabled - Set this flag to true and provide DiskEncryptionKey and optional KeyEncryptionKey to enable encryption. Set this flag to false and remove DiskEncryptionKey and KeyEncryptionKey to disable encryption. If EncryptionSettings is null in the request object, the existing settings remain unchanged.
+ Enabled *bool `json:"enabled,omitempty"`
+ // DiskEncryptionKey - Key Vault Secret Url and vault id of the disk encryption key
+ DiskEncryptionKey *KeyVaultAndSecretReference `json:"diskEncryptionKey,omitempty"`
+ // KeyEncryptionKey - Key Vault Key Url and vault id of the key encryption key
+ KeyEncryptionKey *KeyVaultAndKeyReference `json:"keyEncryptionKey,omitempty"`
+}
+
+// GrantAccessData data used for requesting a SAS.
+type GrantAccessData struct {
+ // Access - Possible values include: 'None', 'Read'
+ Access AccessLevel `json:"access,omitempty"`
+ // DurationInSeconds - Time duration in seconds until the SAS access expires.
+ DurationInSeconds *int32 `json:"durationInSeconds,omitempty"`
+}
+
+// HardwareProfile specifies the hardware settings for the virtual machine.
+type HardwareProfile struct {
+ // VMSize - Specifies the size of the virtual machine. For more information about virtual machine sizes, see [Sizes for virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-sizes?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
The available VM sizes depend on region and availability set. For a list of available sizes use these APIs:
[List all available virtual machine sizes in an availability set](https://docs.microsoft.com/rest/api/compute/availabilitysets/listavailablesizes)
[List all available virtual machine sizes in a region](https://docs.microsoft.com/rest/api/compute/virtualmachinesizes/list)
[List all available virtual machine sizes for resizing](https://docs.microsoft.com/rest/api/compute/virtualmachines/listavailablesizes). Possible values include: 'BasicA0', 'BasicA1', 'BasicA2', 'BasicA3', 'BasicA4', 'StandardA0', 'StandardA1', 'StandardA2', 'StandardA3', 'StandardA4', 'StandardA5', 'StandardA6', 'StandardA7', 'StandardA8', 'StandardA9', 'StandardA10', 'StandardA11', 'StandardA1V2', 'StandardA2V2', 'StandardA4V2', 'StandardA8V2', 'StandardA2mV2', 'StandardA4mV2', 'StandardA8mV2', 'StandardB1s', 'StandardB1ms', 'StandardB2s', 'StandardB2ms', 'StandardB4ms', 'StandardB8ms', 'StandardD1', 'StandardD2', 'StandardD3', 'StandardD4', 'StandardD11', 'StandardD12', 'StandardD13', 'StandardD14', 'StandardD1V2', 'StandardD2V2', 'StandardD3V2', 'StandardD4V2', 'StandardD5V2', 'StandardD2V3', 'StandardD4V3', 'StandardD8V3', 'StandardD16V3', 'StandardD32V3', 'StandardD64V3', 'StandardD2sV3', 'StandardD4sV3', 'StandardD8sV3', 'StandardD16sV3', 'StandardD32sV3', 'StandardD64sV3', 'StandardD11V2', 'StandardD12V2', 'StandardD13V2', 'StandardD14V2', 'StandardD15V2', 'StandardDS1', 'StandardDS2', 'StandardDS3', 'StandardDS4', 'StandardDS11', 'StandardDS12', 'StandardDS13', 'StandardDS14', 'StandardDS1V2', 'StandardDS2V2', 'StandardDS3V2', 'StandardDS4V2', 'StandardDS5V2', 'StandardDS11V2', 'StandardDS12V2', 'StandardDS13V2', 'StandardDS14V2', 'StandardDS15V2', 'StandardDS134V2', 'StandardDS132V2', 'StandardDS148V2', 'StandardDS144V2', 'StandardE2V3', 'StandardE4V3', 'StandardE8V3', 'StandardE16V3', 'StandardE32V3', 'StandardE64V3', 'StandardE2sV3', 'StandardE4sV3', 'StandardE8sV3', 'StandardE16sV3', 'StandardE32sV3', 'StandardE64sV3', 'StandardE3216V3', 'StandardE328sV3', 'StandardE6432sV3', 'StandardE6416sV3', 'StandardF1', 'StandardF2', 'StandardF4', 'StandardF8', 'StandardF16', 'StandardF1s', 'StandardF2s', 'StandardF4s', 'StandardF8s', 'StandardF16s', 'StandardF2sV2', 'StandardF4sV2', 'StandardF8sV2', 'StandardF16sV2', 'StandardF32sV2', 'StandardF64sV2', 'StandardF72sV2', 'StandardG1', 'StandardG2', 'StandardG3', 'StandardG4', 'StandardG5', 'StandardGS1', 'StandardGS2', 'StandardGS3', 'StandardGS4', 'StandardGS5', 'StandardGS48', 'StandardGS44', 'StandardGS516', 'StandardGS58', 'StandardH8', 'StandardH16', 'StandardH8m', 'StandardH16m', 'StandardH16r', 'StandardH16mr', 'StandardL4s', 'StandardL8s', 'StandardL16s', 'StandardL32s', 'StandardM64s', 'StandardM64ms', 'StandardM128s', 'StandardM128ms', 'StandardM6432ms', 'StandardM6416ms', 'StandardM12864ms', 'StandardM12832ms', 'StandardNC6', 'StandardNC12', 'StandardNC24', 'StandardNC24r', 'StandardNC6sV2', 'StandardNC12sV2', 'StandardNC24sV2', 'StandardNC24rsV2', 'StandardNC6sV3', 'StandardNC12sV3', 'StandardNC24sV3', 'StandardNC24rsV3', 'StandardND6s', 'StandardND12s', 'StandardND24s', 'StandardND24rs', 'StandardNV6', 'StandardNV12', 'StandardNV24'
+ VMSize VirtualMachineSizeTypes `json:"vmSize,omitempty"`
+}
+
+// Image the source user image virtual hard disk. The virtual hard disk will be copied before being
+// attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not
+// exist.
+type Image struct {
+ autorest.Response `json:"-"`
+ *ImageProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Image.
+func (i Image) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if i.ImageProperties != nil {
+ objectMap["properties"] = i.ImageProperties
+ }
+ if i.Location != nil {
+ objectMap["location"] = i.Location
+ }
+ if i.Tags != nil {
+ objectMap["tags"] = i.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Image struct.
+func (i *Image) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var imageProperties ImageProperties
+ err = json.Unmarshal(*v, &imageProperties)
+ if err != nil {
+ return err
+ }
+ i.ImageProperties = &imageProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ i.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ i.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ i.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ i.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ i.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// ImageDataDisk describes a data disk.
+type ImageDataDisk struct {
+ // Lun - Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
+ Lun *int32 `json:"lun,omitempty"`
+ // Snapshot - The snapshot.
+ Snapshot *SubResource `json:"snapshot,omitempty"`
+ // ManagedDisk - The managedDisk.
+ ManagedDisk *SubResource `json:"managedDisk,omitempty"`
+ // BlobURI - The Virtual Hard Disk.
+ BlobURI *string `json:"blobUri,omitempty"`
+ // Caching - Specifies the caching requirements.
Possible values are:
**None**
**ReadOnly**
**ReadWrite**
Default: **None for Standard storage. ReadOnly for Premium storage**. Possible values include: 'CachingTypesNone', 'CachingTypesReadOnly', 'CachingTypesReadWrite'
+ Caching CachingTypes `json:"caching,omitempty"`
+ // DiskSizeGB - Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image.
This value cannot be larger than 1023 GB
+ DiskSizeGB *int32 `json:"diskSizeGB,omitempty"`
+ // StorageAccountType - Specifies the storage account type for the managed disk. Possible values are: Standard_LRS or Premium_LRS. Possible values include: 'StandardLRS', 'PremiumLRS'
+ StorageAccountType StorageAccountTypes `json:"storageAccountType,omitempty"`
+}
+
+// ImageDiskReference the source image used for creating the disk.
+type ImageDiskReference struct {
+ // ID - A relative uri containing either a Platform Image Repository or user image reference.
+ ID *string `json:"id,omitempty"`
+ // Lun - If the disk is created from an image's data disk, this is an index that indicates which of the data disks in the image to use. For OS disks, this field is null.
+ Lun *int32 `json:"lun,omitempty"`
+}
+
+// ImageListResult the List Image operation response.
+type ImageListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of Images.
+ Value *[]Image `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of Images. Call ListNext() with this to fetch the next page of Images.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ImageListResultIterator provides access to a complete listing of Image values.
+type ImageListResultIterator struct {
+ i int
+ page ImageListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ImageListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImageListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ImageListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ImageListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ImageListResultIterator) Response() ImageListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ImageListResultIterator) Value() Image {
+ if !iter.page.NotDone() {
+ return Image{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ImageListResultIterator type.
+func NewImageListResultIterator(page ImageListResultPage) ImageListResultIterator {
+ return ImageListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (ilr ImageListResult) IsEmpty() bool {
+ return ilr.Value == nil || len(*ilr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (ilr ImageListResult) hasNextLink() bool {
+ return ilr.NextLink != nil && len(*ilr.NextLink) != 0
+}
+
+// imageListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (ilr ImageListResult) imageListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !ilr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(ilr.NextLink)))
+}
+
+// ImageListResultPage contains a page of Image values.
+type ImageListResultPage struct {
+ fn func(context.Context, ImageListResult) (ImageListResult, error)
+ ilr ImageListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ImageListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ImageListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.ilr)
+ if err != nil {
+ return err
+ }
+ page.ilr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ImageListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ImageListResultPage) NotDone() bool {
+ return !page.ilr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ImageListResultPage) Response() ImageListResult {
+ return page.ilr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ImageListResultPage) Values() []Image {
+ if page.ilr.IsEmpty() {
+ return nil
+ }
+ return *page.ilr.Value
+}
+
+// Creates a new instance of the ImageListResultPage type.
+func NewImageListResultPage(cur ImageListResult, getNextPage func(context.Context, ImageListResult) (ImageListResult, error)) ImageListResultPage {
+ return ImageListResultPage{
+ fn: getNextPage,
+ ilr: cur,
+ }
+}
+
+// ImageOSDisk describes an Operating System disk.
+type ImageOSDisk struct {
+ // OsType - This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image.
Possible values are:
**Windows**
**Linux**. Possible values include: 'Windows', 'Linux'
+ OsType OperatingSystemTypes `json:"osType,omitempty"`
+ // OsState - The OS State. Possible values include: 'Generalized', 'Specialized'
+ OsState OperatingSystemStateTypes `json:"osState,omitempty"`
+ // Snapshot - The snapshot.
+ Snapshot *SubResource `json:"snapshot,omitempty"`
+ // ManagedDisk - The managedDisk.
+ ManagedDisk *SubResource `json:"managedDisk,omitempty"`
+ // BlobURI - The Virtual Hard Disk.
+ BlobURI *string `json:"blobUri,omitempty"`
+ // Caching - Specifies the caching requirements.
Possible values are:
**None**
**ReadOnly**
**ReadWrite**
Default: **None for Standard storage. ReadOnly for Premium storage**. Possible values include: 'CachingTypesNone', 'CachingTypesReadOnly', 'CachingTypesReadWrite'
+ Caching CachingTypes `json:"caching,omitempty"`
+ // DiskSizeGB - Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image.
This value cannot be larger than 1023 GB
+ DiskSizeGB *int32 `json:"diskSizeGB,omitempty"`
+ // StorageAccountType - Specifies the storage account type for the managed disk. Possible values are: Standard_LRS or Premium_LRS. Possible values include: 'StandardLRS', 'PremiumLRS'
+ StorageAccountType StorageAccountTypes `json:"storageAccountType,omitempty"`
+}
+
+// ImageProperties describes the properties of an Image.
+type ImageProperties struct {
+ // SourceVirtualMachine - The source virtual machine from which Image is created.
+ SourceVirtualMachine *SubResource `json:"sourceVirtualMachine,omitempty"`
+ // StorageProfile - Specifies the storage settings for the virtual machine disks.
+ StorageProfile *ImageStorageProfile `json:"storageProfile,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ImageProperties.
+func (IP ImageProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if IP.SourceVirtualMachine != nil {
+ objectMap["sourceVirtualMachine"] = IP.SourceVirtualMachine
+ }
+ if IP.StorageProfile != nil {
+ objectMap["storageProfile"] = IP.StorageProfile
+ }
+ return json.Marshal(objectMap)
+}
+
+// ImageReference specifies information about the image to use. You can specify information about platform
+// images, marketplace images, or virtual machine images. This element is required when you want to use a
+// platform image, marketplace image, or virtual machine image, but is not used in other creation
+// operations. NOTE: Image reference publisher and offer can only be set when you create the scale set.
+type ImageReference struct {
+ // Publisher - The image publisher.
+ Publisher *string `json:"publisher,omitempty"`
+ // Offer - Specifies the offer of the platform image or marketplace image used to create the virtual machine.
+ Offer *string `json:"offer,omitempty"`
+ // Sku - The image SKU.
+ Sku *string `json:"sku,omitempty"`
+ // Version - Specifies the version of the platform image or marketplace image used to create the virtual machine. The allowed formats are Major.Minor.Build or 'latest'. Major, Minor, and Build are decimal numbers. Specify 'latest' to use the latest version of an image available at deploy time. Even if you use 'latest', the VM image will not automatically update after deploy time even if a new version becomes available.
+ Version *string `json:"version,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// ImagesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type ImagesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ImagesClient) (Image, error)
+}
+
+// ImagesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running operation.
+type ImagesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ImagesClient) (OperationStatusResponse, error)
+}
+
+// ImageStorageProfile describes a storage profile.
+type ImageStorageProfile struct {
+ // OsDisk - Specifies information about the operating system disk used by the virtual machine.
For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+ OsDisk *ImageOSDisk `json:"osDisk,omitempty"`
+ // DataDisks - Specifies the parameters that are used to add a data disk to a virtual machine.
For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+ DataDisks *[]ImageDataDisk `json:"dataDisks,omitempty"`
+ // ZoneResilient - Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
+ ZoneResilient *bool `json:"zoneResilient,omitempty"`
+}
+
+// ImagesUpdateFuture an abstraction for monitoring and retrieving the results of a long-running operation.
+type ImagesUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ImagesClient) (Image, error)
+}
+
+// ImageUpdate the source user image virtual hard disk. Only tags may be updated.
+type ImageUpdate struct {
+ *ImageProperties `json:"properties,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for ImageUpdate.
+func (iu ImageUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if iu.ImageProperties != nil {
+ objectMap["properties"] = iu.ImageProperties
+ }
+ if iu.Tags != nil {
+ objectMap["tags"] = iu.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ImageUpdate struct.
+func (iu *ImageUpdate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var imageProperties ImageProperties
+ err = json.Unmarshal(*v, &imageProperties)
+ if err != nil {
+ return err
+ }
+ iu.ImageProperties = &imageProperties
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ iu.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// InnerError inner error details.
+type InnerError struct {
+ // Exceptiontype - The exception type.
+ Exceptiontype *string `json:"exceptiontype,omitempty"`
+ // Errordetail - The internal error message or exception dump.
+ Errordetail *string `json:"errordetail,omitempty"`
+}
+
+// InstanceViewStatus instance view status.
+type InstanceViewStatus struct {
+ // Code - The status code.
+ Code *string `json:"code,omitempty"`
+ // Level - The level code. Possible values include: 'Info', 'Warning', 'Error'
+ Level StatusLevelTypes `json:"level,omitempty"`
+ // DisplayStatus - The short localizable label for the status.
+ DisplayStatus *string `json:"displayStatus,omitempty"`
+ // Message - The detailed status message, including for alerts and error messages.
+ Message *string `json:"message,omitempty"`
+ // Time - The time of the status.
+ Time *date.Time `json:"time,omitempty"`
+}
+
+// KeyVaultAndKeyReference key Vault Key Url and vault id of KeK, KeK is optional and when provided is used
+// to unwrap the encryptionKey
+type KeyVaultAndKeyReference struct {
+ // SourceVault - Resource id of the KeyVault containing the key or secret
+ SourceVault *SourceVault `json:"sourceVault,omitempty"`
+ // KeyURL - Url pointing to a key or secret in KeyVault
+ KeyURL *string `json:"keyUrl,omitempty"`
+}
+
+// KeyVaultAndSecretReference key Vault Secret Url and vault id of the encryption key
+type KeyVaultAndSecretReference struct {
+ // SourceVault - Resource id of the KeyVault containing the key or secret
+ SourceVault *SourceVault `json:"sourceVault,omitempty"`
+ // SecretURL - Url pointing to a key or secret in KeyVault
+ SecretURL *string `json:"secretUrl,omitempty"`
+}
+
+// KeyVaultKeyReference describes a reference to Key Vault Key
+type KeyVaultKeyReference struct {
+ // KeyURL - The URL referencing a key encryption key in Key Vault.
+ KeyURL *string `json:"keyUrl,omitempty"`
+ // SourceVault - The relative URL of the Key Vault containing the key.
+ SourceVault *SubResource `json:"sourceVault,omitempty"`
+}
+
+// KeyVaultSecretReference describes a reference to Key Vault Secret
+type KeyVaultSecretReference struct {
+ // SecretURL - The URL referencing a secret in a Key Vault.
+ SecretURL *string `json:"secretUrl,omitempty"`
+ // SourceVault - The relative URL of the Key Vault containing the secret.
+ SourceVault *SubResource `json:"sourceVault,omitempty"`
+}
+
+// LinuxConfiguration specifies the Linux operating system settings on the virtual machine.
For a
+// list of supported Linux distributions, see [Linux on Azure-Endorsed
+// Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
+//
For running non-endorsed distributions, see [Information for Non-Endorsed
+// Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
+type LinuxConfiguration struct {
+ // DisablePasswordAuthentication - Specifies whether password authentication should be disabled.
+ DisablePasswordAuthentication *bool `json:"disablePasswordAuthentication,omitempty"`
+ // SSH - Specifies the ssh key configuration for a Linux OS.
+ SSH *SSHConfiguration `json:"ssh,omitempty"`
+}
+
+// ListUsagesResult the List Usages operation response.
+type ListUsagesResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of compute resource usages.
+ Value *[]Usage `json:"value,omitempty"`
+ // NextLink - The URI to fetch the next page of compute resource usage information. Call ListNext() with this to fetch the next page of compute resource usage information.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ListUsagesResultIterator provides access to a complete listing of Usage values.
+type ListUsagesResultIterator struct {
+ i int
+ page ListUsagesResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ListUsagesResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ListUsagesResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ListUsagesResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ListUsagesResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ListUsagesResultIterator) Response() ListUsagesResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ListUsagesResultIterator) Value() Usage {
+ if !iter.page.NotDone() {
+ return Usage{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ListUsagesResultIterator type.
+func NewListUsagesResultIterator(page ListUsagesResultPage) ListUsagesResultIterator {
+ return ListUsagesResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (lur ListUsagesResult) IsEmpty() bool {
+ return lur.Value == nil || len(*lur.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (lur ListUsagesResult) hasNextLink() bool {
+ return lur.NextLink != nil && len(*lur.NextLink) != 0
+}
+
+// listUsagesResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (lur ListUsagesResult) listUsagesResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !lur.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(lur.NextLink)))
+}
+
+// ListUsagesResultPage contains a page of Usage values.
+type ListUsagesResultPage struct {
+ fn func(context.Context, ListUsagesResult) (ListUsagesResult, error)
+ lur ListUsagesResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ListUsagesResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ListUsagesResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.lur)
+ if err != nil {
+ return err
+ }
+ page.lur = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ListUsagesResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ListUsagesResultPage) NotDone() bool {
+ return !page.lur.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ListUsagesResultPage) Response() ListUsagesResult {
+ return page.lur
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ListUsagesResultPage) Values() []Usage {
+ if page.lur.IsEmpty() {
+ return nil
+ }
+ return *page.lur.Value
+}
+
+// Creates a new instance of the ListUsagesResultPage type.
+func NewListUsagesResultPage(cur ListUsagesResult, getNextPage func(context.Context, ListUsagesResult) (ListUsagesResult, error)) ListUsagesResultPage {
+ return ListUsagesResultPage{
+ fn: getNextPage,
+ lur: cur,
+ }
+}
+
+// ListVirtualMachineExtensionImage ...
+type ListVirtualMachineExtensionImage struct {
+ autorest.Response `json:"-"`
+ Value *[]VirtualMachineExtensionImage `json:"value,omitempty"`
+}
+
+// ListVirtualMachineImageResource ...
+type ListVirtualMachineImageResource struct {
+ autorest.Response `json:"-"`
+ Value *[]VirtualMachineImageResource `json:"value,omitempty"`
+}
+
+// LogAnalyticsExportRequestRateByIntervalFuture an abstraction for monitoring and retrieving the results
+// of a long-running operation.
+type LogAnalyticsExportRequestRateByIntervalFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LogAnalyticsClient) (LogAnalyticsOperationResult, error)
+}
+
+// LogAnalyticsExportThrottledRequestsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type LogAnalyticsExportThrottledRequestsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LogAnalyticsClient) (LogAnalyticsOperationResult, error)
+}
+
+// LogAnalyticsInputBase api input base class for LogAnalytics Api.
+type LogAnalyticsInputBase struct {
+ // BlobContainerSasURI - SAS Uri of the logging blob container to which LogAnalytics Api writes output logs to.
+ BlobContainerSasURI *string `json:"blobContainerSasUri,omitempty"`
+ // FromTime - From time of the query
+ FromTime *date.Time `json:"fromTime,omitempty"`
+ // ToTime - To time of the query
+ ToTime *date.Time `json:"toTime,omitempty"`
+ // GroupByThrottlePolicy - Group query result by Throttle Policy applied.
+ GroupByThrottlePolicy *bool `json:"groupByThrottlePolicy,omitempty"`
+ // GroupByOperationName - Group query result by Operation Name.
+ GroupByOperationName *bool `json:"groupByOperationName,omitempty"`
+ // GroupByResourceName - Group query result by Resource Name.
+ GroupByResourceName *bool `json:"groupByResourceName,omitempty"`
+}
+
+// LogAnalyticsOperationResult logAnalytics operation status response
+type LogAnalyticsOperationResult struct {
+ autorest.Response `json:"-"`
+ // Properties - READ-ONLY; LogAnalyticsOutput
+ Properties *LogAnalyticsOutput `json:"properties,omitempty"`
+ // Name - READ-ONLY; Operation ID
+ Name *string `json:"name,omitempty"`
+ // Status - READ-ONLY; Operation status
+ Status *string `json:"status,omitempty"`
+ // StartTime - READ-ONLY; Start time of the operation
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // EndTime - READ-ONLY; End time of the operation
+ EndTime *date.Time `json:"endTime,omitempty"`
+ // Error - READ-ONLY; Api error
+ Error *APIError `json:"error,omitempty"`
+}
+
+// LogAnalyticsOutput logAnalytics output properties
+type LogAnalyticsOutput struct {
+ // Output - READ-ONLY; Output file Uri path to blob container.
+ Output *string `json:"output,omitempty"`
+}
+
+// LongRunningOperationProperties compute-specific operation properties, including output
+type LongRunningOperationProperties struct {
+ // Output - Operation output data (raw JSON)
+ Output interface{} `json:"output,omitempty"`
+}
+
+// MaintenanceRedeployStatus maintenance Operation Status.
+type MaintenanceRedeployStatus struct {
+ // IsCustomerInitiatedMaintenanceAllowed - True, if customer is allowed to perform Maintenance.
+ IsCustomerInitiatedMaintenanceAllowed *bool `json:"isCustomerInitiatedMaintenanceAllowed,omitempty"`
+ // PreMaintenanceWindowStartTime - Start Time for the Pre Maintenance Window.
+ PreMaintenanceWindowStartTime *date.Time `json:"preMaintenanceWindowStartTime,omitempty"`
+ // PreMaintenanceWindowEndTime - End Time for the Pre Maintenance Window.
+ PreMaintenanceWindowEndTime *date.Time `json:"preMaintenanceWindowEndTime,omitempty"`
+ // MaintenanceWindowStartTime - Start Time for the Maintenance Window.
+ MaintenanceWindowStartTime *date.Time `json:"maintenanceWindowStartTime,omitempty"`
+ // MaintenanceWindowEndTime - End Time for the Maintenance Window.
+ MaintenanceWindowEndTime *date.Time `json:"maintenanceWindowEndTime,omitempty"`
+ // LastOperationResultCode - The Last Maintenance Operation Result Code. Possible values include: 'MaintenanceOperationResultCodeTypesNone', 'MaintenanceOperationResultCodeTypesRetryLater', 'MaintenanceOperationResultCodeTypesMaintenanceAborted', 'MaintenanceOperationResultCodeTypesMaintenanceCompleted'
+ LastOperationResultCode MaintenanceOperationResultCodeTypes `json:"lastOperationResultCode,omitempty"`
+ // LastOperationMessage - Message returned for the last Maintenance Operation.
+ LastOperationMessage *string `json:"lastOperationMessage,omitempty"`
+}
+
+// ManagedDiskParameters the parameters of a managed disk.
+type ManagedDiskParameters struct {
+ // StorageAccountType - Specifies the storage account type for the managed disk. Possible values are: Standard_LRS or Premium_LRS. Possible values include: 'StandardLRS', 'PremiumLRS'
+ StorageAccountType StorageAccountTypes `json:"storageAccountType,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// NetworkInterfaceReference describes a network interface reference.
+type NetworkInterfaceReference struct {
+ *NetworkInterfaceReferenceProperties `json:"properties,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for NetworkInterfaceReference.
+func (nir NetworkInterfaceReference) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if nir.NetworkInterfaceReferenceProperties != nil {
+ objectMap["properties"] = nir.NetworkInterfaceReferenceProperties
+ }
+ if nir.ID != nil {
+ objectMap["id"] = nir.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for NetworkInterfaceReference struct.
+func (nir *NetworkInterfaceReference) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var networkInterfaceReferenceProperties NetworkInterfaceReferenceProperties
+ err = json.Unmarshal(*v, &networkInterfaceReferenceProperties)
+ if err != nil {
+ return err
+ }
+ nir.NetworkInterfaceReferenceProperties = &networkInterfaceReferenceProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ nir.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// NetworkInterfaceReferenceProperties describes a network interface reference properties.
+type NetworkInterfaceReferenceProperties struct {
+ // Primary - Specifies the primary network interface in case the virtual machine has more than 1 network interface.
+ Primary *bool `json:"primary,omitempty"`
+}
+
+// NetworkProfile specifies the network interfaces of the virtual machine.
+type NetworkProfile struct {
+ // NetworkInterfaces - Specifies the list of resource Ids for the network interfaces associated with the virtual machine.
+ NetworkInterfaces *[]NetworkInterfaceReference `json:"networkInterfaces,omitempty"`
+}
+
+// OperationListResult the List Compute Operation operation response.
+type OperationListResult struct {
+ autorest.Response `json:"-"`
+ // Value - READ-ONLY; The list of compute operations
+ Value *[]OperationValue `json:"value,omitempty"`
+}
+
+// OperationStatusResponse operation status response
+type OperationStatusResponse struct {
+ autorest.Response `json:"-"`
+ // Name - READ-ONLY; Operation ID
+ Name *string `json:"name,omitempty"`
+ // Status - READ-ONLY; Operation status
+ Status *string `json:"status,omitempty"`
+ // StartTime - READ-ONLY; Start time of the operation
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // EndTime - READ-ONLY; End time of the operation
+ EndTime *date.Time `json:"endTime,omitempty"`
+ // Error - READ-ONLY; Api error
+ Error *APIError `json:"error,omitempty"`
+}
+
+// OperationValue describes the properties of a Compute Operation value.
+type OperationValue struct {
+ // Origin - READ-ONLY; The origin of the compute operation.
+ Origin *string `json:"origin,omitempty"`
+ // Name - READ-ONLY; The name of the compute operation.
+ Name *string `json:"name,omitempty"`
+ *OperationValueDisplay `json:"display,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for OperationValue.
+func (ov OperationValue) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ov.OperationValueDisplay != nil {
+ objectMap["display"] = ov.OperationValueDisplay
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for OperationValue struct.
+func (ov *OperationValue) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "origin":
+ if v != nil {
+ var origin string
+ err = json.Unmarshal(*v, &origin)
+ if err != nil {
+ return err
+ }
+ ov.Origin = &origin
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ ov.Name = &name
+ }
+ case "display":
+ if v != nil {
+ var operationValueDisplay OperationValueDisplay
+ err = json.Unmarshal(*v, &operationValueDisplay)
+ if err != nil {
+ return err
+ }
+ ov.OperationValueDisplay = &operationValueDisplay
+ }
+ }
+ }
+
+ return nil
+}
+
+// OperationValueDisplay describes the properties of a Compute Operation Value Display.
+type OperationValueDisplay struct {
+ // Operation - READ-ONLY; The display name of the compute operation.
+ Operation *string `json:"operation,omitempty"`
+ // Resource - READ-ONLY; The display name of the resource the operation applies to.
+ Resource *string `json:"resource,omitempty"`
+ // Description - READ-ONLY; The description of the operation.
+ Description *string `json:"description,omitempty"`
+ // Provider - READ-ONLY; The resource provider for the operation.
+ Provider *string `json:"provider,omitempty"`
+}
+
+// OSDisk specifies information about the operating system disk used by the virtual machine.
For
+// more information about disks, see [About disks and VHDs for Azure virtual
+// machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+type OSDisk struct {
+ // OsType - This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD.
Possible values are:
**Windows**
**Linux**. Possible values include: 'Windows', 'Linux'
+ OsType OperatingSystemTypes `json:"osType,omitempty"`
+ // EncryptionSettings - Specifies the encryption settings for the OS Disk.
Minimum api-version: 2015-06-15
+ EncryptionSettings *DiskEncryptionSettings `json:"encryptionSettings,omitempty"`
+ // Name - The disk name.
+ Name *string `json:"name,omitempty"`
+ // Vhd - The virtual hard disk.
+ Vhd *VirtualHardDisk `json:"vhd,omitempty"`
+ // Image - The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
+ Image *VirtualHardDisk `json:"image,omitempty"`
+ // Caching - Specifies the caching requirements.
Possible values are:
**None**
**ReadOnly**
**ReadWrite**
Default: **None for Standard storage. ReadOnly for Premium storage**. Possible values include: 'CachingTypesNone', 'CachingTypesReadOnly', 'CachingTypesReadWrite'
+ Caching CachingTypes `json:"caching,omitempty"`
+ // WriteAcceleratorEnabled - Specifies whether writeAccelerator should be enabled or disabled on the disk.
+ WriteAcceleratorEnabled *bool `json:"writeAcceleratorEnabled,omitempty"`
+ // CreateOption - Specifies how the virtual machine should be created.
Possible values are:
**Attach** \u2013 This value is used when you are using a specialized disk to create the virtual machine.
**FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described. Possible values include: 'DiskCreateOptionTypesFromImage', 'DiskCreateOptionTypesEmpty', 'DiskCreateOptionTypesAttach'
+ CreateOption DiskCreateOptionTypes `json:"createOption,omitempty"`
+ // DiskSizeGB - Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image.
This value cannot be larger than 1023 GB
+ DiskSizeGB *int32 `json:"diskSizeGB,omitempty"`
+ // ManagedDisk - The managed disk parameters.
+ ManagedDisk *ManagedDiskParameters `json:"managedDisk,omitempty"`
+}
+
+// OSDiskImage contains the os disk image information.
+type OSDiskImage struct {
+ // OperatingSystem - The operating system of the osDiskImage. Possible values include: 'Windows', 'Linux'
+ OperatingSystem OperatingSystemTypes `json:"operatingSystem,omitempty"`
+}
+
+// OSProfile specifies the operating system settings for the virtual machine.
+type OSProfile struct {
+ // ComputerName - Specifies the host OS name of the virtual machine.
This name cannot be updated after the VM is created.
**Max-length (Windows):** 15 characters
**Max-length (Linux):** 64 characters.
For naming conventions and restrictions see [Azure infrastructure services implementation guidelines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-infrastructure-subscription-accounts-guidelines?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#1-naming-conventions).
+ ComputerName *string `json:"computerName,omitempty"`
+ // AdminUsername - Specifies the name of the administrator account.
**Windows-only restriction:** Cannot end in "."
**Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5".
**Minimum-length (Linux):** 1 character
**Max-length (Linux):** 64 characters
**Max-length (Windows):** 20 characters
For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
+ AdminUsername *string `json:"adminUsername,omitempty"`
+ // AdminPassword - Specifies the password of the administrator account.
**Minimum-length (Windows):** 8 characters
**Minimum-length (Linux):** 6 characters
**Max-length (Windows):** 123 characters
**Max-length (Linux):** 72 characters
**Complexity requirements:** 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])
**Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!"
For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
+ AdminPassword *string `json:"adminPassword,omitempty"`
+ // CustomData - Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes.
For using cloud-init for your VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
+ CustomData *string `json:"customData,omitempty"`
+ // WindowsConfiguration - Specifies Windows operating system settings on the virtual machine.
+ WindowsConfiguration *WindowsConfiguration `json:"windowsConfiguration,omitempty"`
+ // LinuxConfiguration - Specifies the Linux operating system settings on the virtual machine.
For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
+ LinuxConfiguration *LinuxConfiguration `json:"linuxConfiguration,omitempty"`
+ // Secrets - Specifies set of certificates that should be installed onto the virtual machine.
+ Secrets *[]VaultSecretGroup `json:"secrets,omitempty"`
+}
+
+// Plan specifies information about the marketplace image used to create the virtual machine. This element
+// is only used for marketplace images. Before you can use a marketplace image from an API, you must enable
+// the image for programmatic use. In the Azure portal, find the marketplace image that you want to use
+// and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and
+// then click **Save**.
+type Plan struct {
+ // Name - The plan ID.
+ Name *string `json:"name,omitempty"`
+ // Publisher - The publisher ID.
+ Publisher *string `json:"publisher,omitempty"`
+ // Product - Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
+ Product *string `json:"product,omitempty"`
+ // PromotionCode - The promotion code.
+ PromotionCode *string `json:"promotionCode,omitempty"`
+}
+
+// PurchasePlan used for establishing the purchase context of any 3rd Party artifact through MarketPlace.
+type PurchasePlan struct {
+ // Publisher - The publisher ID.
+ Publisher *string `json:"publisher,omitempty"`
+ // Name - The plan ID.
+ Name *string `json:"name,omitempty"`
+ // Product - Specifies the product of the image from the marketplace. This is the same value as Offer under the imageReference element.
+ Product *string `json:"product,omitempty"`
+}
+
+// RecoveryWalkResponse response after calling a manual recovery walk
+type RecoveryWalkResponse struct {
+ autorest.Response `json:"-"`
+ // WalkPerformed - READ-ONLY; Whether the recovery walk was performed
+ WalkPerformed *bool `json:"walkPerformed,omitempty"`
+ // NextPlatformUpdateDomain - READ-ONLY; The next update domain that needs to be walked. Null means walk spanning all update domains has been completed
+ NextPlatformUpdateDomain *int32 `json:"nextPlatformUpdateDomain,omitempty"`
+}
+
+// RequestRateByIntervalInput api request input for LogAnalytics getRequestRateByInterval Api.
+type RequestRateByIntervalInput struct {
+ // IntervalLength - Interval value in minutes used to create LogAnalytics call rate logs. Possible values include: 'ThreeMins', 'FiveMins', 'ThirtyMins', 'SixtyMins'
+ IntervalLength IntervalInMins `json:"intervalLength,omitempty"`
+ // BlobContainerSasURI - SAS Uri of the logging blob container to which LogAnalytics Api writes output logs to.
+ BlobContainerSasURI *string `json:"blobContainerSasUri,omitempty"`
+ // FromTime - From time of the query
+ FromTime *date.Time `json:"fromTime,omitempty"`
+ // ToTime - To time of the query
+ ToTime *date.Time `json:"toTime,omitempty"`
+ // GroupByThrottlePolicy - Group query result by Throttle Policy applied.
+ GroupByThrottlePolicy *bool `json:"groupByThrottlePolicy,omitempty"`
+ // GroupByOperationName - Group query result by Operation Name.
+ GroupByOperationName *bool `json:"groupByOperationName,omitempty"`
+ // GroupByResourceName - Group query result by Resource Name.
+ GroupByResourceName *bool `json:"groupByResourceName,omitempty"`
+}
+
+// Resource the Resource model definition.
+type Resource struct {
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Resource.
+func (r Resource) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if r.Location != nil {
+ objectMap["location"] = r.Location
+ }
+ if r.Tags != nil {
+ objectMap["tags"] = r.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// ResourceSku describes an available Compute SKU.
+type ResourceSku struct {
+ // ResourceType - READ-ONLY; The type of resource the SKU applies to.
+ ResourceType *string `json:"resourceType,omitempty"`
+ // Name - READ-ONLY; The name of SKU.
+ Name *string `json:"name,omitempty"`
+ // Tier - READ-ONLY; Specifies the tier of virtual machines in a scale set.
Possible Values:
**Standard**
**Basic**
+ Tier *string `json:"tier,omitempty"`
+ // Size - READ-ONLY; The Size of the SKU.
+ Size *string `json:"size,omitempty"`
+ // Family - READ-ONLY; The Family of this particular SKU.
+ Family *string `json:"family,omitempty"`
+ // Kind - READ-ONLY; The Kind of resources that are supported in this SKU.
+ Kind *string `json:"kind,omitempty"`
+ // Capacity - READ-ONLY; Specifies the number of virtual machines in the scale set.
+ Capacity *ResourceSkuCapacity `json:"capacity,omitempty"`
+ // Locations - READ-ONLY; The set of locations that the SKU is available.
+ Locations *[]string `json:"locations,omitempty"`
+ // LocationInfo - READ-ONLY; A list of locations and availability zones in those locations where the SKU is available.
+ LocationInfo *[]ResourceSkuLocationInfo `json:"locationInfo,omitempty"`
+ // APIVersions - READ-ONLY; The api versions that support this SKU.
+ APIVersions *[]string `json:"apiVersions,omitempty"`
+ // Costs - READ-ONLY; Metadata for retrieving price info.
+ Costs *[]ResourceSkuCosts `json:"costs,omitempty"`
+ // Capabilities - READ-ONLY; A name value pair to describe the capability.
+ Capabilities *[]ResourceSkuCapabilities `json:"capabilities,omitempty"`
+ // Restrictions - READ-ONLY; The restrictions because of which SKU cannot be used. This is empty if there are no restrictions.
+ Restrictions *[]ResourceSkuRestrictions `json:"restrictions,omitempty"`
+}
+
+// ResourceSkuCapabilities describes The SKU capabilities object.
+type ResourceSkuCapabilities struct {
+ // Name - READ-ONLY; An invariant to describe the feature.
+ Name *string `json:"name,omitempty"`
+ // Value - READ-ONLY; An invariant if the feature is measured by quantity.
+ Value *string `json:"value,omitempty"`
+}
+
+// ResourceSkuCapacity describes scaling information of a SKU.
+type ResourceSkuCapacity struct {
+ // Minimum - READ-ONLY; The minimum capacity.
+ Minimum *int64 `json:"minimum,omitempty"`
+ // Maximum - READ-ONLY; The maximum capacity that can be set.
+ Maximum *int64 `json:"maximum,omitempty"`
+ // Default - READ-ONLY; The default capacity.
+ Default *int64 `json:"default,omitempty"`
+ // ScaleType - READ-ONLY; The scale type applicable to the sku. Possible values include: 'ResourceSkuCapacityScaleTypeAutomatic', 'ResourceSkuCapacityScaleTypeManual', 'ResourceSkuCapacityScaleTypeNone'
+ ScaleType ResourceSkuCapacityScaleType `json:"scaleType,omitempty"`
+}
+
+// ResourceSkuCosts describes metadata for retrieving price info.
+type ResourceSkuCosts struct {
+ // MeterID - READ-ONLY; Used for querying price from commerce.
+ MeterID *string `json:"meterID,omitempty"`
+ // Quantity - READ-ONLY; The multiplier is needed to extend the base metered cost.
+ Quantity *int64 `json:"quantity,omitempty"`
+ // ExtendedUnit - READ-ONLY; An invariant to show the extended unit.
+ ExtendedUnit *string `json:"extendedUnit,omitempty"`
+}
+
+// ResourceSkuLocationInfo ...
+type ResourceSkuLocationInfo struct {
+ // Location - READ-ONLY; Location of the SKU
+ Location *string `json:"location,omitempty"`
+ // Zones - READ-ONLY; List of availability zones where the SKU is supported.
+ Zones *[]string `json:"zones,omitempty"`
+}
+
+// ResourceSkuRestrictionInfo ...
+type ResourceSkuRestrictionInfo struct {
+ // Locations - READ-ONLY; Locations where the SKU is restricted
+ Locations *[]string `json:"locations,omitempty"`
+ // Zones - READ-ONLY; List of availability zones where the SKU is restricted.
+ Zones *[]string `json:"zones,omitempty"`
+}
+
+// ResourceSkuRestrictions describes scaling information of a SKU.
+type ResourceSkuRestrictions struct {
+ // Type - READ-ONLY; The type of restrictions. Possible values include: 'Location', 'Zone'
+ Type ResourceSkuRestrictionsType `json:"type,omitempty"`
+ // Values - READ-ONLY; The value of restrictions. If the restriction type is set to location. This would be different locations where the SKU is restricted.
+ Values *[]string `json:"values,omitempty"`
+ // RestrictionInfo - READ-ONLY; The information about the restriction where the SKU cannot be used.
+ RestrictionInfo *ResourceSkuRestrictionInfo `json:"restrictionInfo,omitempty"`
+ // ReasonCode - READ-ONLY; The reason for restriction. Possible values include: 'QuotaID', 'NotAvailableForSubscription'
+ ReasonCode ResourceSkuRestrictionsReasonCode `json:"reasonCode,omitempty"`
+}
+
+// ResourceSkusResult the List Resource Skus operation response.
+type ResourceSkusResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of skus available for the subscription.
+ Value *[]ResourceSku `json:"value,omitempty"`
+ // NextLink - The URI to fetch the next page of Resource Skus. Call ListNext() with this URI to fetch the next page of Resource Skus
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ResourceSkusResultIterator provides access to a complete listing of ResourceSku values.
+type ResourceSkusResultIterator struct {
+ i int
+ page ResourceSkusResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ResourceSkusResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSkusResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ResourceSkusResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ResourceSkusResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ResourceSkusResultIterator) Response() ResourceSkusResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ResourceSkusResultIterator) Value() ResourceSku {
+ if !iter.page.NotDone() {
+ return ResourceSku{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ResourceSkusResultIterator type.
+func NewResourceSkusResultIterator(page ResourceSkusResultPage) ResourceSkusResultIterator {
+ return ResourceSkusResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (rsr ResourceSkusResult) IsEmpty() bool {
+ return rsr.Value == nil || len(*rsr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (rsr ResourceSkusResult) hasNextLink() bool {
+ return rsr.NextLink != nil && len(*rsr.NextLink) != 0
+}
+
+// resourceSkusResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (rsr ResourceSkusResult) resourceSkusResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !rsr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(rsr.NextLink)))
+}
+
+// ResourceSkusResultPage contains a page of ResourceSku values.
+type ResourceSkusResultPage struct {
+ fn func(context.Context, ResourceSkusResult) (ResourceSkusResult, error)
+ rsr ResourceSkusResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ResourceSkusResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSkusResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.rsr)
+ if err != nil {
+ return err
+ }
+ page.rsr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ResourceSkusResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ResourceSkusResultPage) NotDone() bool {
+ return !page.rsr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ResourceSkusResultPage) Response() ResourceSkusResult {
+ return page.rsr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ResourceSkusResultPage) Values() []ResourceSku {
+ if page.rsr.IsEmpty() {
+ return nil
+ }
+ return *page.rsr.Value
+}
+
+// Creates a new instance of the ResourceSkusResultPage type.
+func NewResourceSkusResultPage(cur ResourceSkusResult, getNextPage func(context.Context, ResourceSkusResult) (ResourceSkusResult, error)) ResourceSkusResultPage {
+ return ResourceSkusResultPage{
+ fn: getNextPage,
+ rsr: cur,
+ }
+}
+
+// ResourceUpdate the Resource model definition.
+type ResourceUpdate struct {
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+ Sku *DiskSku `json:"sku,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ResourceUpdate.
+func (ru ResourceUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ru.Tags != nil {
+ objectMap["tags"] = ru.Tags
+ }
+ if ru.Sku != nil {
+ objectMap["sku"] = ru.Sku
+ }
+ return json.Marshal(objectMap)
+}
+
+// RollbackStatusInfo information about rollback on failed VM instances after a OS Upgrade operation.
+type RollbackStatusInfo struct {
+ // SuccessfullyRolledbackInstanceCount - READ-ONLY; The number of instances which have been successfully rolled back.
+ SuccessfullyRolledbackInstanceCount *int32 `json:"successfullyRolledbackInstanceCount,omitempty"`
+ // FailedRolledbackInstanceCount - READ-ONLY; The number of instances which failed to rollback.
+ FailedRolledbackInstanceCount *int32 `json:"failedRolledbackInstanceCount,omitempty"`
+ // RollbackError - READ-ONLY; Error details if OS rollback failed.
+ RollbackError *APIError `json:"rollbackError,omitempty"`
+}
+
+// RollingUpgradePolicy the configuration parameters used while performing a rolling upgrade.
+type RollingUpgradePolicy struct {
+ // MaxBatchInstancePercent - The maximum percent of total virtual machine instances that will be upgraded simultaneously by the rolling upgrade in one batch. As this is a maximum, unhealthy instances in previous or future batches can cause the percentage of instances in a batch to decrease to ensure higher reliability. The default value for this parameter is 20%.
+ MaxBatchInstancePercent *int32 `json:"maxBatchInstancePercent,omitempty"`
+ // MaxUnhealthyInstancePercent - The maximum percentage of the total virtual machine instances in the scale set that can be simultaneously unhealthy, either as a result of being upgraded, or by being found in an unhealthy state by the virtual machine health checks before the rolling upgrade aborts. This constraint will be checked prior to starting any batch. The default value for this parameter is 20%.
+ MaxUnhealthyInstancePercent *int32 `json:"maxUnhealthyInstancePercent,omitempty"`
+ // MaxUnhealthyUpgradedInstancePercent - The maximum percentage of upgraded virtual machine instances that can be found to be in an unhealthy state. This check will happen after each batch is upgraded. If this percentage is ever exceeded, the rolling update aborts. The default value for this parameter is 20%.
+ MaxUnhealthyUpgradedInstancePercent *int32 `json:"maxUnhealthyUpgradedInstancePercent,omitempty"`
+ // PauseTimeBetweenBatches - The wait time between completing the update for all virtual machines in one batch and starting the next batch. The time duration should be specified in ISO 8601 format. The default value is 0 seconds (PT0S).
+ PauseTimeBetweenBatches *string `json:"pauseTimeBetweenBatches,omitempty"`
+}
+
+// RollingUpgradeProgressInfo information about the number of virtual machine instances in each upgrade
+// state.
+type RollingUpgradeProgressInfo struct {
+ // SuccessfulInstanceCount - READ-ONLY; The number of instances that have been successfully upgraded.
+ SuccessfulInstanceCount *int32 `json:"successfulInstanceCount,omitempty"`
+ // FailedInstanceCount - READ-ONLY; The number of instances that have failed to be upgraded successfully.
+ FailedInstanceCount *int32 `json:"failedInstanceCount,omitempty"`
+ // InProgressInstanceCount - READ-ONLY; The number of instances that are currently being upgraded.
+ InProgressInstanceCount *int32 `json:"inProgressInstanceCount,omitempty"`
+ // PendingInstanceCount - READ-ONLY; The number of instances that have not yet begun to be upgraded.
+ PendingInstanceCount *int32 `json:"pendingInstanceCount,omitempty"`
+}
+
+// RollingUpgradeRunningStatus information about the current running state of the overall upgrade.
+type RollingUpgradeRunningStatus struct {
+ // Code - READ-ONLY; Code indicating the current status of the upgrade. Possible values include: 'RollingForward', 'Cancelled', 'Completed', 'Faulted'
+ Code RollingUpgradeStatusCode `json:"code,omitempty"`
+ // StartTime - READ-ONLY; Start time of the upgrade.
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // LastAction - READ-ONLY; The last action performed on the rolling upgrade. Possible values include: 'Start', 'Cancel'
+ LastAction RollingUpgradeActionType `json:"lastAction,omitempty"`
+ // LastActionTime - READ-ONLY; Last action time of the upgrade.
+ LastActionTime *date.Time `json:"lastActionTime,omitempty"`
+}
+
+// RollingUpgradeStatusInfo the status of the latest virtual machine scale set rolling upgrade.
+type RollingUpgradeStatusInfo struct {
+ autorest.Response `json:"-"`
+ *RollingUpgradeStatusInfoProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for RollingUpgradeStatusInfo.
+func (rusi RollingUpgradeStatusInfo) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rusi.RollingUpgradeStatusInfoProperties != nil {
+ objectMap["properties"] = rusi.RollingUpgradeStatusInfoProperties
+ }
+ if rusi.Location != nil {
+ objectMap["location"] = rusi.Location
+ }
+ if rusi.Tags != nil {
+ objectMap["tags"] = rusi.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for RollingUpgradeStatusInfo struct.
+func (rusi *RollingUpgradeStatusInfo) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var rollingUpgradeStatusInfoProperties RollingUpgradeStatusInfoProperties
+ err = json.Unmarshal(*v, &rollingUpgradeStatusInfoProperties)
+ if err != nil {
+ return err
+ }
+ rusi.RollingUpgradeStatusInfoProperties = &rollingUpgradeStatusInfoProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ rusi.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ rusi.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ rusi.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ rusi.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ rusi.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// RollingUpgradeStatusInfoProperties the status of the latest virtual machine scale set rolling upgrade.
+type RollingUpgradeStatusInfoProperties struct {
+ // Policy - READ-ONLY; The rolling upgrade policies applied for this upgrade.
+ Policy *RollingUpgradePolicy `json:"policy,omitempty"`
+ // RunningStatus - READ-ONLY; Information about the current running state of the overall upgrade.
+ RunningStatus *RollingUpgradeRunningStatus `json:"runningStatus,omitempty"`
+ // Progress - READ-ONLY; Information about the number of virtual machine instances in each upgrade state.
+ Progress *RollingUpgradeProgressInfo `json:"progress,omitempty"`
+ // Error - READ-ONLY; Error details for this upgrade, if there are any.
+ Error *APIError `json:"error,omitempty"`
+}
+
+// RunCommandDocument describes the properties of a Run Command.
+type RunCommandDocument struct {
+ autorest.Response `json:"-"`
+ // Script - The script to be executed.
+ Script *[]string `json:"script,omitempty"`
+ // Parameters - The parameters used by the script.
+ Parameters *[]RunCommandParameterDefinition `json:"parameters,omitempty"`
+ // Schema - The VM run command schema.
+ Schema *string `json:"$schema,omitempty"`
+ // ID - The VM run command id.
+ ID *string `json:"id,omitempty"`
+ // OsType - The Operating System type. Possible values include: 'Windows', 'Linux'
+ OsType OperatingSystemTypes `json:"osType,omitempty"`
+ // Label - The VM run command label.
+ Label *string `json:"label,omitempty"`
+ // Description - The VM run command description.
+ Description *string `json:"description,omitempty"`
+}
+
+// RunCommandDocumentBase describes the properties of a Run Command metadata.
+type RunCommandDocumentBase struct {
+ // Schema - The VM run command schema.
+ Schema *string `json:"$schema,omitempty"`
+ // ID - The VM run command id.
+ ID *string `json:"id,omitempty"`
+ // OsType - The Operating System type. Possible values include: 'Windows', 'Linux'
+ OsType OperatingSystemTypes `json:"osType,omitempty"`
+ // Label - The VM run command label.
+ Label *string `json:"label,omitempty"`
+ // Description - The VM run command description.
+ Description *string `json:"description,omitempty"`
+}
+
+// RunCommandInput capture Virtual Machine parameters.
+type RunCommandInput struct {
+ // CommandID - The run command id.
+ CommandID *string `json:"commandId,omitempty"`
+ // Script - Optional. The script to be executed. When this value is given, the given script will override the default script of the command.
+ Script *[]string `json:"script,omitempty"`
+ // Parameters - The run command parameters.
+ Parameters *[]RunCommandInputParameter `json:"parameters,omitempty"`
+}
+
+// RunCommandInputParameter describes the properties of a run command parameter.
+type RunCommandInputParameter struct {
+ // Name - The run command parameter name.
+ Name *string `json:"name,omitempty"`
+ // Value - The run command parameter value.
+ Value *string `json:"value,omitempty"`
+}
+
+// RunCommandListResult the List Virtual Machine operation response.
+type RunCommandListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of virtual machine run commands.
+ Value *[]RunCommandDocumentBase `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of run commands. Call ListNext() with this to fetch the next page of run commands.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// RunCommandListResultIterator provides access to a complete listing of RunCommandDocumentBase values.
+type RunCommandListResultIterator struct {
+ i int
+ page RunCommandListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *RunCommandListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RunCommandListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *RunCommandListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter RunCommandListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter RunCommandListResultIterator) Response() RunCommandListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter RunCommandListResultIterator) Value() RunCommandDocumentBase {
+ if !iter.page.NotDone() {
+ return RunCommandDocumentBase{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the RunCommandListResultIterator type.
+func NewRunCommandListResultIterator(page RunCommandListResultPage) RunCommandListResultIterator {
+ return RunCommandListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (rclr RunCommandListResult) IsEmpty() bool {
+ return rclr.Value == nil || len(*rclr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (rclr RunCommandListResult) hasNextLink() bool {
+ return rclr.NextLink != nil && len(*rclr.NextLink) != 0
+}
+
+// runCommandListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (rclr RunCommandListResult) runCommandListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !rclr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(rclr.NextLink)))
+}
+
+// RunCommandListResultPage contains a page of RunCommandDocumentBase values.
+type RunCommandListResultPage struct {
+ fn func(context.Context, RunCommandListResult) (RunCommandListResult, error)
+ rclr RunCommandListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *RunCommandListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RunCommandListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.rclr)
+ if err != nil {
+ return err
+ }
+ page.rclr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *RunCommandListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page RunCommandListResultPage) NotDone() bool {
+ return !page.rclr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page RunCommandListResultPage) Response() RunCommandListResult {
+ return page.rclr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page RunCommandListResultPage) Values() []RunCommandDocumentBase {
+ if page.rclr.IsEmpty() {
+ return nil
+ }
+ return *page.rclr.Value
+}
+
+// Creates a new instance of the RunCommandListResultPage type.
+func NewRunCommandListResultPage(cur RunCommandListResult, getNextPage func(context.Context, RunCommandListResult) (RunCommandListResult, error)) RunCommandListResultPage {
+ return RunCommandListResultPage{
+ fn: getNextPage,
+ rclr: cur,
+ }
+}
+
+// RunCommandParameterDefinition describes the properties of a run command parameter.
+type RunCommandParameterDefinition struct {
+ // Name - The run command parameter name.
+ Name *string `json:"name,omitempty"`
+ // Type - The run command parameter type.
+ Type *string `json:"type,omitempty"`
+ // DefaultValue - The run command parameter default value.
+ DefaultValue *string `json:"defaultValue,omitempty"`
+ // Required - The run command parameter required.
+ Required *bool `json:"required,omitempty"`
+}
+
+// RunCommandResult run command operation response.
+type RunCommandResult struct {
+ autorest.Response `json:"-"`
+ *RunCommandResultProperties `json:"properties,omitempty"`
+ // Name - READ-ONLY; Operation ID
+ Name *string `json:"name,omitempty"`
+ // Status - READ-ONLY; Operation status
+ Status *string `json:"status,omitempty"`
+ // StartTime - READ-ONLY; Start time of the operation
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // EndTime - READ-ONLY; End time of the operation
+ EndTime *date.Time `json:"endTime,omitempty"`
+ // Error - READ-ONLY; Api error
+ Error *APIError `json:"error,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for RunCommandResult.
+func (rcr RunCommandResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rcr.RunCommandResultProperties != nil {
+ objectMap["properties"] = rcr.RunCommandResultProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for RunCommandResult struct.
+func (rcr *RunCommandResult) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var runCommandResultProperties RunCommandResultProperties
+ err = json.Unmarshal(*v, &runCommandResultProperties)
+ if err != nil {
+ return err
+ }
+ rcr.RunCommandResultProperties = &runCommandResultProperties
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ rcr.Name = &name
+ }
+ case "status":
+ if v != nil {
+ var status string
+ err = json.Unmarshal(*v, &status)
+ if err != nil {
+ return err
+ }
+ rcr.Status = &status
+ }
+ case "startTime":
+ if v != nil {
+ var startTime date.Time
+ err = json.Unmarshal(*v, &startTime)
+ if err != nil {
+ return err
+ }
+ rcr.StartTime = &startTime
+ }
+ case "endTime":
+ if v != nil {
+ var endTime date.Time
+ err = json.Unmarshal(*v, &endTime)
+ if err != nil {
+ return err
+ }
+ rcr.EndTime = &endTime
+ }
+ case "error":
+ if v != nil {
+ var errorVar APIError
+ err = json.Unmarshal(*v, &errorVar)
+ if err != nil {
+ return err
+ }
+ rcr.Error = &errorVar
+ }
+ }
+ }
+
+ return nil
+}
+
+// RunCommandResultProperties compute-specific operation properties, including output
+type RunCommandResultProperties struct {
+ // Output - Operation output data (raw JSON)
+ Output interface{} `json:"output,omitempty"`
+}
+
+// Sku describes a virtual machine scale set sku. NOTE: If the new VM SKU is not supported on the hardware
+// the scale set is currently on, you need to deallocate the VMs in the scale set before you modify the SKU
+// name.
+type Sku struct {
+ // Name - The sku name.
+ Name *string `json:"name,omitempty"`
+ // Tier - Specifies the tier of virtual machines in a scale set.
Possible Values:
**Standard**
**Basic**
+ Tier *string `json:"tier,omitempty"`
+ // Capacity - Specifies the number of virtual machines in the scale set.
+ Capacity *int64 `json:"capacity,omitempty"`
+}
+
+// Snapshot snapshot resource.
+type Snapshot struct {
+ autorest.Response `json:"-"`
+ // ManagedBy - READ-ONLY; Unused. Always Null.
+ ManagedBy *string `json:"managedBy,omitempty"`
+ Sku *DiskSku `json:"sku,omitempty"`
+ *DiskProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Snapshot.
+func (s Snapshot) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if s.Sku != nil {
+ objectMap["sku"] = s.Sku
+ }
+ if s.DiskProperties != nil {
+ objectMap["properties"] = s.DiskProperties
+ }
+ if s.Location != nil {
+ objectMap["location"] = s.Location
+ }
+ if s.Tags != nil {
+ objectMap["tags"] = s.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Snapshot struct.
+func (s *Snapshot) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "managedBy":
+ if v != nil {
+ var managedBy string
+ err = json.Unmarshal(*v, &managedBy)
+ if err != nil {
+ return err
+ }
+ s.ManagedBy = &managedBy
+ }
+ case "sku":
+ if v != nil {
+ var sku DiskSku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ s.Sku = &sku
+ }
+ case "properties":
+ if v != nil {
+ var diskProperties DiskProperties
+ err = json.Unmarshal(*v, &diskProperties)
+ if err != nil {
+ return err
+ }
+ s.DiskProperties = &diskProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ s.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ s.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ s.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ s.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ s.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// SnapshotList the List Snapshots operation response.
+type SnapshotList struct {
+ autorest.Response `json:"-"`
+ // Value - A list of snapshots.
+ Value *[]Snapshot `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of snapshots. Call ListNext() with this to fetch the next page of snapshots.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SnapshotListIterator provides access to a complete listing of Snapshot values.
+type SnapshotListIterator struct {
+ i int
+ page SnapshotListPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *SnapshotListIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotListIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *SnapshotListIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter SnapshotListIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter SnapshotListIterator) Response() SnapshotList {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter SnapshotListIterator) Value() Snapshot {
+ if !iter.page.NotDone() {
+ return Snapshot{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the SnapshotListIterator type.
+func NewSnapshotListIterator(page SnapshotListPage) SnapshotListIterator {
+ return SnapshotListIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (sl SnapshotList) IsEmpty() bool {
+ return sl.Value == nil || len(*sl.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (sl SnapshotList) hasNextLink() bool {
+ return sl.NextLink != nil && len(*sl.NextLink) != 0
+}
+
+// snapshotListPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (sl SnapshotList) snapshotListPreparer(ctx context.Context) (*http.Request, error) {
+ if !sl.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(sl.NextLink)))
+}
+
+// SnapshotListPage contains a page of Snapshot values.
+type SnapshotListPage struct {
+ fn func(context.Context, SnapshotList) (SnapshotList, error)
+ sl SnapshotList
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *SnapshotListPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotListPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.sl)
+ if err != nil {
+ return err
+ }
+ page.sl = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *SnapshotListPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page SnapshotListPage) NotDone() bool {
+ return !page.sl.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page SnapshotListPage) Response() SnapshotList {
+ return page.sl
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page SnapshotListPage) Values() []Snapshot {
+ if page.sl.IsEmpty() {
+ return nil
+ }
+ return *page.sl.Value
+}
+
+// Creates a new instance of the SnapshotListPage type.
+func NewSnapshotListPage(cur SnapshotList, getNextPage func(context.Context, SnapshotList) (SnapshotList, error)) SnapshotListPage {
+ return SnapshotListPage{
+ fn: getNextPage,
+ sl: cur,
+ }
+}
+
+// SnapshotsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SnapshotsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SnapshotsClient) (Snapshot, error)
+}
+
+// SnapshotsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SnapshotsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SnapshotsClient) (OperationStatusResponse, error)
+}
+
+// SnapshotsGrantAccessFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SnapshotsGrantAccessFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SnapshotsClient) (AccessURI, error)
+}
+
+// SnapshotsRevokeAccessFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SnapshotsRevokeAccessFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SnapshotsClient) (OperationStatusResponse, error)
+}
+
+// SnapshotsUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SnapshotsUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SnapshotsClient) (Snapshot, error)
+}
+
+// SnapshotUpdate snapshot update resource.
+type SnapshotUpdate struct {
+ *DiskUpdateProperties `json:"properties,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+ Sku *DiskSku `json:"sku,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for SnapshotUpdate.
+func (su SnapshotUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if su.DiskUpdateProperties != nil {
+ objectMap["properties"] = su.DiskUpdateProperties
+ }
+ if su.Tags != nil {
+ objectMap["tags"] = su.Tags
+ }
+ if su.Sku != nil {
+ objectMap["sku"] = su.Sku
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for SnapshotUpdate struct.
+func (su *SnapshotUpdate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var diskUpdateProperties DiskUpdateProperties
+ err = json.Unmarshal(*v, &diskUpdateProperties)
+ if err != nil {
+ return err
+ }
+ su.DiskUpdateProperties = &diskUpdateProperties
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ su.Tags = tags
+ }
+ case "sku":
+ if v != nil {
+ var sku DiskSku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ su.Sku = &sku
+ }
+ }
+ }
+
+ return nil
+}
+
+// SourceVault the vault id is an Azure Resource Manager Resource id in the form
+// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}
+type SourceVault struct {
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// SSHConfiguration SSH configuration for Linux based VMs running on Azure
+type SSHConfiguration struct {
+ // PublicKeys - The list of SSH public keys used to authenticate with linux based VMs.
+ PublicKeys *[]SSHPublicKey `json:"publicKeys,omitempty"`
+}
+
+// SSHPublicKey contains information about SSH certificate public key and the path on the Linux VM where
+// the public key is placed.
+type SSHPublicKey struct {
+ // Path - Specifies the full path on the created VM where ssh public key is stored. If the file already exists, the specified key is appended to the file. Example: /home/user/.ssh/authorized_keys
+ Path *string `json:"path,omitempty"`
+ // KeyData - SSH public key certificate used to authenticate with the VM through ssh. The key needs to be at least 2048-bit and in ssh-rsa format.
For creating ssh keys, see [Create SSH keys on Linux and Mac for Linux VMs in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-mac-create-ssh-keys?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
+ KeyData *string `json:"keyData,omitempty"`
+}
+
+// StorageProfile specifies the storage settings for the virtual machine disks.
+type StorageProfile struct {
+ // ImageReference - Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
+ ImageReference *ImageReference `json:"imageReference,omitempty"`
+ // OsDisk - Specifies information about the operating system disk used by the virtual machine.
For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+ OsDisk *OSDisk `json:"osDisk,omitempty"`
+ // DataDisks - Specifies the parameters that are used to add a data disk to a virtual machine.
For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+ DataDisks *[]DataDisk `json:"dataDisks,omitempty"`
+}
+
+// SubResource ...
+type SubResource struct {
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// SubResourceReadOnly ...
+type SubResourceReadOnly struct {
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// ThrottledRequestsInput api request input for LogAnalytics getThrottledRequests Api.
+type ThrottledRequestsInput struct {
+ // BlobContainerSasURI - SAS Uri of the logging blob container to which LogAnalytics Api writes output logs to.
+ BlobContainerSasURI *string `json:"blobContainerSasUri,omitempty"`
+ // FromTime - From time of the query
+ FromTime *date.Time `json:"fromTime,omitempty"`
+ // ToTime - To time of the query
+ ToTime *date.Time `json:"toTime,omitempty"`
+ // GroupByThrottlePolicy - Group query result by Throttle Policy applied.
+ GroupByThrottlePolicy *bool `json:"groupByThrottlePolicy,omitempty"`
+ // GroupByOperationName - Group query result by Operation Name.
+ GroupByOperationName *bool `json:"groupByOperationName,omitempty"`
+ // GroupByResourceName - Group query result by Resource Name.
+ GroupByResourceName *bool `json:"groupByResourceName,omitempty"`
+}
+
+// UpdateResource the Update Resource model definition.
+type UpdateResource struct {
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for UpdateResource.
+func (ur UpdateResource) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ur.Tags != nil {
+ objectMap["tags"] = ur.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UpgradeOperationHistoricalStatusInfo virtual Machine Scale Set OS Upgrade History operation response.
+type UpgradeOperationHistoricalStatusInfo struct {
+ // Properties - READ-ONLY; Information about the properties of the upgrade operation.
+ Properties *UpgradeOperationHistoricalStatusInfoProperties `json:"properties,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - READ-ONLY; Resource location
+ Location *string `json:"location,omitempty"`
+}
+
+// UpgradeOperationHistoricalStatusInfoProperties describes each OS upgrade on the Virtual Machine Scale
+// Set.
+type UpgradeOperationHistoricalStatusInfoProperties struct {
+ // RunningStatus - READ-ONLY; Information about the overall status of the upgrade operation.
+ RunningStatus *UpgradeOperationHistoryStatus `json:"runningStatus,omitempty"`
+ // Progress - READ-ONLY; Counts of the VMs in each state.
+ Progress *RollingUpgradeProgressInfo `json:"progress,omitempty"`
+ // Error - READ-ONLY; Error Details for this upgrade if there are any.
+ Error *APIError `json:"error,omitempty"`
+ // StartedBy - READ-ONLY; Invoker of the Upgrade Operation. Possible values include: 'Unknown', 'User', 'Platform'
+ StartedBy UpgradeOperationInvoker `json:"startedBy,omitempty"`
+ // TargetImageReference - READ-ONLY; Image Reference details
+ TargetImageReference *ImageReference `json:"targetImageReference,omitempty"`
+ // RollbackInfo - READ-ONLY; Information about OS rollback if performed
+ RollbackInfo *RollbackStatusInfo `json:"rollbackInfo,omitempty"`
+}
+
+// UpgradeOperationHistoryStatus information about the current running state of the overall upgrade.
+type UpgradeOperationHistoryStatus struct {
+ // Code - READ-ONLY; Code indicating the current status of the upgrade. Possible values include: 'UpgradeStateRollingForward', 'UpgradeStateCancelled', 'UpgradeStateCompleted', 'UpgradeStateFaulted'
+ Code UpgradeState `json:"code,omitempty"`
+ // StartTime - READ-ONLY; Start time of the upgrade.
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // EndTime - READ-ONLY; End time of the upgrade.
+ EndTime *date.Time `json:"endTime,omitempty"`
+}
+
+// UpgradePolicy describes an upgrade policy - automatic, manual, or rolling.
+type UpgradePolicy struct {
+ // Mode - Specifies the mode of an upgrade to virtual machines in the scale set.
Possible values are:
**Manual** - You control the application of updates to virtual machines in the scale set. You do this by using the manualUpgrade action.
**Automatic** - All virtual machines in the scale set are automatically updated at the same time. Possible values include: 'Automatic', 'Manual', 'Rolling'
+ Mode UpgradeMode `json:"mode,omitempty"`
+ // RollingUpgradePolicy - The configuration parameters used while performing a rolling upgrade.
+ RollingUpgradePolicy *RollingUpgradePolicy `json:"rollingUpgradePolicy,omitempty"`
+ // AutomaticOSUpgrade - Whether OS upgrades should automatically be applied to scale set instances in a rolling fashion when a newer version of the image becomes available.
+ AutomaticOSUpgrade *bool `json:"automaticOSUpgrade,omitempty"`
+ // AutoOSUpgradePolicy - Configuration parameters used for performing automatic OS Upgrade.
+ AutoOSUpgradePolicy *AutoOSUpgradePolicy `json:"autoOSUpgradePolicy,omitempty"`
+}
+
+// Usage describes Compute Resource Usage.
+type Usage struct {
+ // Unit - An enum describing the unit of usage measurement.
+ Unit *string `json:"unit,omitempty"`
+ // CurrentValue - The current usage of the resource.
+ CurrentValue *int32 `json:"currentValue,omitempty"`
+ // Limit - The maximum permitted usage of the resource.
+ Limit *int64 `json:"limit,omitempty"`
+ // Name - The name of the type of usage.
+ Name *UsageName `json:"name,omitempty"`
+}
+
+// UsageName the Usage Names.
+type UsageName struct {
+ // Value - The name of the resource.
+ Value *string `json:"value,omitempty"`
+ // LocalizedValue - The localized name of the resource.
+ LocalizedValue *string `json:"localizedValue,omitempty"`
+}
+
+// VaultCertificate describes a single certificate reference in a Key Vault, and where the certificate
+// should reside on the VM.
+type VaultCertificate struct {
+ // CertificateURL - This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8:
{
"data":"",
"dataType":"pfx",
"password":""
}
+ CertificateURL *string `json:"certificateUrl,omitempty"`
+ // CertificateStore - For Windows VMs, specifies the certificate store on the Virtual Machine to which the certificate should be added. The specified certificate store is implicitly in the LocalMachine account.
For Linux VMs, the certificate file is placed under the /var/lib/waagent directory, with the file name <UppercaseThumbprint>.crt for the X509 certificate file and <UppercaseThumbprint>.prv for private key. Both of these files are .pem formatted.
+ CertificateStore *string `json:"certificateStore,omitempty"`
+}
+
+// VaultSecretGroup describes a set of certificates which are all in the same Key Vault.
+type VaultSecretGroup struct {
+ // SourceVault - The relative URL of the Key Vault containing all of the certificates in VaultCertificates.
+ SourceVault *SubResource `json:"sourceVault,omitempty"`
+ // VaultCertificates - The list of key vault references in SourceVault which contain certificates.
+ VaultCertificates *[]VaultCertificate `json:"vaultCertificates,omitempty"`
+}
+
+// VirtualHardDisk describes the uri of a disk.
+type VirtualHardDisk struct {
+ // URI - Specifies the virtual hard disk's uri.
+ URI *string `json:"uri,omitempty"`
+}
+
+// VirtualMachine describes a Virtual Machine.
+type VirtualMachine struct {
+ autorest.Response `json:"-"`
+ // Plan - Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use. In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**.
+ Plan *Plan `json:"plan,omitempty"`
+ *VirtualMachineProperties `json:"properties,omitempty"`
+ // Resources - READ-ONLY; The virtual machine child extension resources.
+ Resources *[]VirtualMachineExtension `json:"resources,omitempty"`
+ // Identity - The identity of the virtual machine, if configured.
+ Identity *VirtualMachineIdentity `json:"identity,omitempty"`
+ // Zones - The virtual machine zones.
+ Zones *[]string `json:"zones,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachine.
+func (VM VirtualMachine) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if VM.Plan != nil {
+ objectMap["plan"] = VM.Plan
+ }
+ if VM.VirtualMachineProperties != nil {
+ objectMap["properties"] = VM.VirtualMachineProperties
+ }
+ if VM.Identity != nil {
+ objectMap["identity"] = VM.Identity
+ }
+ if VM.Zones != nil {
+ objectMap["zones"] = VM.Zones
+ }
+ if VM.Location != nil {
+ objectMap["location"] = VM.Location
+ }
+ if VM.Tags != nil {
+ objectMap["tags"] = VM.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachine struct.
+func (VM *VirtualMachine) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "plan":
+ if v != nil {
+ var plan Plan
+ err = json.Unmarshal(*v, &plan)
+ if err != nil {
+ return err
+ }
+ VM.Plan = &plan
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineProperties VirtualMachineProperties
+ err = json.Unmarshal(*v, &virtualMachineProperties)
+ if err != nil {
+ return err
+ }
+ VM.VirtualMachineProperties = &virtualMachineProperties
+ }
+ case "resources":
+ if v != nil {
+ var resources []VirtualMachineExtension
+ err = json.Unmarshal(*v, &resources)
+ if err != nil {
+ return err
+ }
+ VM.Resources = &resources
+ }
+ case "identity":
+ if v != nil {
+ var identity VirtualMachineIdentity
+ err = json.Unmarshal(*v, &identity)
+ if err != nil {
+ return err
+ }
+ VM.Identity = &identity
+ }
+ case "zones":
+ if v != nil {
+ var zones []string
+ err = json.Unmarshal(*v, &zones)
+ if err != nil {
+ return err
+ }
+ VM.Zones = &zones
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ VM.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ VM.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ VM.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ VM.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ VM.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineAgentInstanceView the instance view of the VM Agent running on the virtual machine.
+type VirtualMachineAgentInstanceView struct {
+ // VMAgentVersion - The VM Agent full version.
+ VMAgentVersion *string `json:"vmAgentVersion,omitempty"`
+ // ExtensionHandlers - The virtual machine extension handler instance view.
+ ExtensionHandlers *[]VirtualMachineExtensionHandlerInstanceView `json:"extensionHandlers,omitempty"`
+ // Statuses - The resource status information.
+ Statuses *[]InstanceViewStatus `json:"statuses,omitempty"`
+}
+
+// VirtualMachineCaptureParameters capture Virtual Machine parameters.
+type VirtualMachineCaptureParameters struct {
+ // VhdPrefix - The captured virtual hard disk's name prefix.
+ VhdPrefix *string `json:"vhdPrefix,omitempty"`
+ // DestinationContainerName - The destination container name.
+ DestinationContainerName *string `json:"destinationContainerName,omitempty"`
+ // OverwriteVhds - Specifies whether to overwrite the destination virtual hard disk, in case of conflict.
+ OverwriteVhds *bool `json:"overwriteVhds,omitempty"`
+}
+
+// VirtualMachineCaptureResult resource Id.
+type VirtualMachineCaptureResult struct {
+ autorest.Response `json:"-"`
+ *VirtualMachineCaptureResultProperties `json:"properties,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineCaptureResult.
+func (vmcr VirtualMachineCaptureResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmcr.VirtualMachineCaptureResultProperties != nil {
+ objectMap["properties"] = vmcr.VirtualMachineCaptureResultProperties
+ }
+ if vmcr.ID != nil {
+ objectMap["id"] = vmcr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineCaptureResult struct.
+func (vmcr *VirtualMachineCaptureResult) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualMachineCaptureResultProperties VirtualMachineCaptureResultProperties
+ err = json.Unmarshal(*v, &virtualMachineCaptureResultProperties)
+ if err != nil {
+ return err
+ }
+ vmcr.VirtualMachineCaptureResultProperties = &virtualMachineCaptureResultProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmcr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineCaptureResultProperties compute-specific operation properties, including output
+type VirtualMachineCaptureResultProperties struct {
+ // Output - Operation output data (raw JSON)
+ Output interface{} `json:"output,omitempty"`
+}
+
+// VirtualMachineExtension describes a Virtual Machine Extension.
+type VirtualMachineExtension struct {
+ autorest.Response `json:"-"`
+ *VirtualMachineExtensionProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineExtension.
+func (vme VirtualMachineExtension) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vme.VirtualMachineExtensionProperties != nil {
+ objectMap["properties"] = vme.VirtualMachineExtensionProperties
+ }
+ if vme.Location != nil {
+ objectMap["location"] = vme.Location
+ }
+ if vme.Tags != nil {
+ objectMap["tags"] = vme.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineExtension struct.
+func (vme *VirtualMachineExtension) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualMachineExtensionProperties VirtualMachineExtensionProperties
+ err = json.Unmarshal(*v, &virtualMachineExtensionProperties)
+ if err != nil {
+ return err
+ }
+ vme.VirtualMachineExtensionProperties = &virtualMachineExtensionProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vme.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vme.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vme.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vme.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vme.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineExtensionHandlerInstanceView the instance view of a virtual machine extension handler.
+type VirtualMachineExtensionHandlerInstanceView struct {
+ // Type - Specifies the type of the extension; an example is "CustomScriptExtension".
+ Type *string `json:"type,omitempty"`
+ // TypeHandlerVersion - Specifies the version of the script handler.
+ TypeHandlerVersion *string `json:"typeHandlerVersion,omitempty"`
+ // Status - The extension handler status.
+ Status *InstanceViewStatus `json:"status,omitempty"`
+}
+
+// VirtualMachineExtensionImage describes a Virtual Machine Extension Image.
+type VirtualMachineExtensionImage struct {
+ autorest.Response `json:"-"`
+ *VirtualMachineExtensionImageProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineExtensionImage.
+func (vmei VirtualMachineExtensionImage) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmei.VirtualMachineExtensionImageProperties != nil {
+ objectMap["properties"] = vmei.VirtualMachineExtensionImageProperties
+ }
+ if vmei.Location != nil {
+ objectMap["location"] = vmei.Location
+ }
+ if vmei.Tags != nil {
+ objectMap["tags"] = vmei.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineExtensionImage struct.
+func (vmei *VirtualMachineExtensionImage) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualMachineExtensionImageProperties VirtualMachineExtensionImageProperties
+ err = json.Unmarshal(*v, &virtualMachineExtensionImageProperties)
+ if err != nil {
+ return err
+ }
+ vmei.VirtualMachineExtensionImageProperties = &virtualMachineExtensionImageProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmei.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmei.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vmei.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vmei.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vmei.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineExtensionImageProperties describes the properties of a Virtual Machine Extension Image.
+type VirtualMachineExtensionImageProperties struct {
+ // OperatingSystem - The operating system this extension supports.
+ OperatingSystem *string `json:"operatingSystem,omitempty"`
+ // ComputeRole - The type of role (IaaS or PaaS) this extension supports.
+ ComputeRole *string `json:"computeRole,omitempty"`
+ // HandlerSchema - The schema defined by publisher, where extension consumers should provide settings in a matching schema.
+ HandlerSchema *string `json:"handlerSchema,omitempty"`
+ // VMScaleSetEnabled - Whether the extension can be used on xRP VMScaleSets. By default existing extensions are usable on scalesets, but there might be cases where a publisher wants to explicitly indicate the extension is only enabled for CRP VMs but not VMSS.
+ VMScaleSetEnabled *bool `json:"vmScaleSetEnabled,omitempty"`
+ // SupportsMultipleExtensions - Whether the handler can support multiple extensions.
+ SupportsMultipleExtensions *bool `json:"supportsMultipleExtensions,omitempty"`
+}
+
+// VirtualMachineExtensionInstanceView the instance view of a virtual machine extension.
+type VirtualMachineExtensionInstanceView struct {
+ // Name - The virtual machine extension name.
+ Name *string `json:"name,omitempty"`
+ // Type - Specifies the type of the extension; an example is "CustomScriptExtension".
+ Type *string `json:"type,omitempty"`
+ // TypeHandlerVersion - Specifies the version of the script handler.
+ TypeHandlerVersion *string `json:"typeHandlerVersion,omitempty"`
+ // Substatuses - The resource status information.
+ Substatuses *[]InstanceViewStatus `json:"substatuses,omitempty"`
+ // Statuses - The resource status information.
+ Statuses *[]InstanceViewStatus `json:"statuses,omitempty"`
+}
+
+// VirtualMachineExtensionProperties describes the properties of a Virtual Machine Extension.
+type VirtualMachineExtensionProperties struct {
+ // ForceUpdateTag - How the extension handler should be forced to update even if the extension configuration has not changed.
+ ForceUpdateTag *string `json:"forceUpdateTag,omitempty"`
+ // Publisher - The name of the extension handler publisher.
+ Publisher *string `json:"publisher,omitempty"`
+ // Type - Specifies the type of the extension; an example is "CustomScriptExtension".
+ Type *string `json:"type,omitempty"`
+ // TypeHandlerVersion - Specifies the version of the script handler.
+ TypeHandlerVersion *string `json:"typeHandlerVersion,omitempty"`
+ // AutoUpgradeMinorVersion - Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
+ AutoUpgradeMinorVersion *bool `json:"autoUpgradeMinorVersion,omitempty"`
+ // Settings - Json formatted public settings for the extension.
+ Settings interface{} `json:"settings,omitempty"`
+ // ProtectedSettings - The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
+ ProtectedSettings interface{} `json:"protectedSettings,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state, which only appears in the response.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // InstanceView - The virtual machine extension instance view.
+ InstanceView *VirtualMachineExtensionInstanceView `json:"instanceView,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineExtensionProperties.
+func (vmep VirtualMachineExtensionProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmep.ForceUpdateTag != nil {
+ objectMap["forceUpdateTag"] = vmep.ForceUpdateTag
+ }
+ if vmep.Publisher != nil {
+ objectMap["publisher"] = vmep.Publisher
+ }
+ if vmep.Type != nil {
+ objectMap["type"] = vmep.Type
+ }
+ if vmep.TypeHandlerVersion != nil {
+ objectMap["typeHandlerVersion"] = vmep.TypeHandlerVersion
+ }
+ if vmep.AutoUpgradeMinorVersion != nil {
+ objectMap["autoUpgradeMinorVersion"] = vmep.AutoUpgradeMinorVersion
+ }
+ if vmep.Settings != nil {
+ objectMap["settings"] = vmep.Settings
+ }
+ if vmep.ProtectedSettings != nil {
+ objectMap["protectedSettings"] = vmep.ProtectedSettings
+ }
+ if vmep.InstanceView != nil {
+ objectMap["instanceView"] = vmep.InstanceView
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineExtensionsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualMachineExtensionsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineExtensionsClient) (VirtualMachineExtension, error)
+}
+
+// VirtualMachineExtensionsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineExtensionsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineExtensionsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineExtensionsListResult the List Extension operation response
+type VirtualMachineExtensionsListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of extensions
+ Value *[]VirtualMachineExtension `json:"value,omitempty"`
+}
+
+// VirtualMachineExtensionsUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineExtensionsUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineExtensionsClient) (VirtualMachineExtension, error)
+}
+
+// VirtualMachineExtensionUpdate describes a Virtual Machine Extension.
+type VirtualMachineExtensionUpdate struct {
+ *VirtualMachineExtensionUpdateProperties `json:"properties,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineExtensionUpdate.
+func (vmeu VirtualMachineExtensionUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmeu.VirtualMachineExtensionUpdateProperties != nil {
+ objectMap["properties"] = vmeu.VirtualMachineExtensionUpdateProperties
+ }
+ if vmeu.Tags != nil {
+ objectMap["tags"] = vmeu.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineExtensionUpdate struct.
+func (vmeu *VirtualMachineExtensionUpdate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualMachineExtensionUpdateProperties VirtualMachineExtensionUpdateProperties
+ err = json.Unmarshal(*v, &virtualMachineExtensionUpdateProperties)
+ if err != nil {
+ return err
+ }
+ vmeu.VirtualMachineExtensionUpdateProperties = &virtualMachineExtensionUpdateProperties
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vmeu.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineExtensionUpdateProperties describes the properties of a Virtual Machine Extension.
+type VirtualMachineExtensionUpdateProperties struct {
+ // ForceUpdateTag - How the extension handler should be forced to update even if the extension configuration has not changed.
+ ForceUpdateTag *string `json:"forceUpdateTag,omitempty"`
+ // Publisher - The name of the extension handler publisher.
+ Publisher *string `json:"publisher,omitempty"`
+ // Type - Specifies the type of the extension; an example is "CustomScriptExtension".
+ Type *string `json:"type,omitempty"`
+ // TypeHandlerVersion - Specifies the version of the script handler.
+ TypeHandlerVersion *string `json:"typeHandlerVersion,omitempty"`
+ // AutoUpgradeMinorVersion - Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
+ AutoUpgradeMinorVersion *bool `json:"autoUpgradeMinorVersion,omitempty"`
+ // Settings - Json formatted public settings for the extension.
+ Settings interface{} `json:"settings,omitempty"`
+ // ProtectedSettings - The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
+ ProtectedSettings interface{} `json:"protectedSettings,omitempty"`
+}
+
+// VirtualMachineHealthStatus the health status of the VM.
+type VirtualMachineHealthStatus struct {
+ // Status - READ-ONLY; The health status information for the VM.
+ Status *InstanceViewStatus `json:"status,omitempty"`
+}
+
+// VirtualMachineIdentity identity for the virtual machine.
+type VirtualMachineIdentity struct {
+ // PrincipalID - READ-ONLY; The principal id of virtual machine identity. This property will only be provided for a system assigned identity.
+ PrincipalID *string `json:"principalId,omitempty"`
+ // TenantID - READ-ONLY; The tenant id associated with the virtual machine. This property will only be provided for a system assigned identity.
+ TenantID *string `json:"tenantId,omitempty"`
+ // Type - The type of identity used for the virtual machine. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine. Possible values include: 'ResourceIdentityTypeSystemAssigned', 'ResourceIdentityTypeUserAssigned', 'ResourceIdentityTypeSystemAssignedUserAssigned', 'ResourceIdentityTypeNone'
+ Type ResourceIdentityType `json:"type,omitempty"`
+ // IdentityIds - The list of user identities associated with the Virtual Machine. The user identity references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/identities/{identityName}'.
+ IdentityIds *[]string `json:"identityIds,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineIdentity.
+func (vmi VirtualMachineIdentity) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmi.Type != "" {
+ objectMap["type"] = vmi.Type
+ }
+ if vmi.IdentityIds != nil {
+ objectMap["identityIds"] = vmi.IdentityIds
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineImage describes a Virtual Machine Image.
+type VirtualMachineImage struct {
+ autorest.Response `json:"-"`
+ *VirtualMachineImageProperties `json:"properties,omitempty"`
+ // Name - The name of the resource.
+ Name *string `json:"name,omitempty"`
+ // Location - The supported Azure location of the resource.
+ Location *string `json:"location,omitempty"`
+ // Tags - Specifies the tags that are assigned to the virtual machine. For more information about using tags, see [Using tags to organize your Azure resources](https://docs.microsoft.com/azure/azure-resource-manager/resource-group-using-tags.md).
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineImage.
+func (vmi VirtualMachineImage) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmi.VirtualMachineImageProperties != nil {
+ objectMap["properties"] = vmi.VirtualMachineImageProperties
+ }
+ if vmi.Name != nil {
+ objectMap["name"] = vmi.Name
+ }
+ if vmi.Location != nil {
+ objectMap["location"] = vmi.Location
+ }
+ if vmi.Tags != nil {
+ objectMap["tags"] = vmi.Tags
+ }
+ if vmi.ID != nil {
+ objectMap["id"] = vmi.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineImage struct.
+func (vmi *VirtualMachineImage) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualMachineImageProperties VirtualMachineImageProperties
+ err = json.Unmarshal(*v, &virtualMachineImageProperties)
+ if err != nil {
+ return err
+ }
+ vmi.VirtualMachineImageProperties = &virtualMachineImageProperties
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmi.Name = &name
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vmi.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vmi.Tags = tags
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmi.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineImageProperties describes the properties of a Virtual Machine Image.
+type VirtualMachineImageProperties struct {
+ Plan *PurchasePlan `json:"plan,omitempty"`
+ OsDiskImage *OSDiskImage `json:"osDiskImage,omitempty"`
+ DataDiskImages *[]DataDiskImage `json:"dataDiskImages,omitempty"`
+}
+
+// VirtualMachineImageResource virtual machine image resource information.
+type VirtualMachineImageResource struct {
+ // Name - The name of the resource.
+ Name *string `json:"name,omitempty"`
+ // Location - The supported Azure location of the resource.
+ Location *string `json:"location,omitempty"`
+ // Tags - Specifies the tags that are assigned to the virtual machine. For more information about using tags, see [Using tags to organize your Azure resources](https://docs.microsoft.com/azure/azure-resource-manager/resource-group-using-tags.md).
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineImageResource.
+func (vmir VirtualMachineImageResource) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmir.Name != nil {
+ objectMap["name"] = vmir.Name
+ }
+ if vmir.Location != nil {
+ objectMap["location"] = vmir.Location
+ }
+ if vmir.Tags != nil {
+ objectMap["tags"] = vmir.Tags
+ }
+ if vmir.ID != nil {
+ objectMap["id"] = vmir.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineInstanceView the instance view of a virtual machine.
+type VirtualMachineInstanceView struct {
+ autorest.Response `json:"-"`
+ // PlatformUpdateDomain - Specifies the update domain of the virtual machine.
+ PlatformUpdateDomain *int32 `json:"platformUpdateDomain,omitempty"`
+ // PlatformFaultDomain - Specifies the fault domain of the virtual machine.
+ PlatformFaultDomain *int32 `json:"platformFaultDomain,omitempty"`
+ // ComputerName - The computer name assigned to the virtual machine.
+ ComputerName *string `json:"computerName,omitempty"`
+ // OsName - The Operating System running on the virtual machine.
+ OsName *string `json:"osName,omitempty"`
+ // OsVersion - The version of Operating System running on the virtual machine.
+ OsVersion *string `json:"osVersion,omitempty"`
+ // RdpThumbPrint - The Remote desktop certificate thumbprint.
+ RdpThumbPrint *string `json:"rdpThumbPrint,omitempty"`
+ // VMAgent - The VM Agent running on the virtual machine.
+ VMAgent *VirtualMachineAgentInstanceView `json:"vmAgent,omitempty"`
+ // MaintenanceRedeployStatus - The Maintenance Operation status on the virtual machine.
+ MaintenanceRedeployStatus *MaintenanceRedeployStatus `json:"maintenanceRedeployStatus,omitempty"`
+ // Disks - The virtual machine disk information.
+ Disks *[]DiskInstanceView `json:"disks,omitempty"`
+ // Extensions - The extensions information.
+ Extensions *[]VirtualMachineExtensionInstanceView `json:"extensions,omitempty"`
+ // BootDiagnostics - Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status.
You can easily view the output of your console log.
Azure also enables you to see a screenshot of the VM from the hypervisor.
+ BootDiagnostics *BootDiagnosticsInstanceView `json:"bootDiagnostics,omitempty"`
+ // Statuses - The resource status information.
+ Statuses *[]InstanceViewStatus `json:"statuses,omitempty"`
+}
+
+// VirtualMachineListResult the List Virtual Machine operation response.
+type VirtualMachineListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of virtual machines.
+ Value *[]VirtualMachine `json:"value,omitempty"`
+ // NextLink - The URI to fetch the next page of VMs. Call ListNext() with this URI to fetch the next page of Virtual Machines.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualMachineListResultIterator provides access to a complete listing of VirtualMachine values.
+type VirtualMachineListResultIterator struct {
+ i int
+ page VirtualMachineListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualMachineListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualMachineListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualMachineListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualMachineListResultIterator) Response() VirtualMachineListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualMachineListResultIterator) Value() VirtualMachine {
+ if !iter.page.NotDone() {
+ return VirtualMachine{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualMachineListResultIterator type.
+func NewVirtualMachineListResultIterator(page VirtualMachineListResultPage) VirtualMachineListResultIterator {
+ return VirtualMachineListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vmlr VirtualMachineListResult) IsEmpty() bool {
+ return vmlr.Value == nil || len(*vmlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vmlr VirtualMachineListResult) hasNextLink() bool {
+ return vmlr.NextLink != nil && len(*vmlr.NextLink) != 0
+}
+
+// virtualMachineListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vmlr VirtualMachineListResult) virtualMachineListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vmlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vmlr.NextLink)))
+}
+
+// VirtualMachineListResultPage contains a page of VirtualMachine values.
+type VirtualMachineListResultPage struct {
+ fn func(context.Context, VirtualMachineListResult) (VirtualMachineListResult, error)
+ vmlr VirtualMachineListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualMachineListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vmlr)
+ if err != nil {
+ return err
+ }
+ page.vmlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualMachineListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualMachineListResultPage) NotDone() bool {
+ return !page.vmlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualMachineListResultPage) Response() VirtualMachineListResult {
+ return page.vmlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualMachineListResultPage) Values() []VirtualMachine {
+ if page.vmlr.IsEmpty() {
+ return nil
+ }
+ return *page.vmlr.Value
+}
+
+// Creates a new instance of the VirtualMachineListResultPage type.
+func NewVirtualMachineListResultPage(cur VirtualMachineListResult, getNextPage func(context.Context, VirtualMachineListResult) (VirtualMachineListResult, error)) VirtualMachineListResultPage {
+ return VirtualMachineListResultPage{
+ fn: getNextPage,
+ vmlr: cur,
+ }
+}
+
+// VirtualMachineProperties describes the properties of a Virtual Machine.
+type VirtualMachineProperties struct {
+ // HardwareProfile - Specifies the hardware settings for the virtual machine.
+ HardwareProfile *HardwareProfile `json:"hardwareProfile,omitempty"`
+ // StorageProfile - Specifies the storage settings for the virtual machine disks.
+ StorageProfile *StorageProfile `json:"storageProfile,omitempty"`
+ // OsProfile - Specifies the operating system settings for the virtual machine.
+ OsProfile *OSProfile `json:"osProfile,omitempty"`
+ // NetworkProfile - Specifies the network interfaces of the virtual machine.
+ NetworkProfile *NetworkProfile `json:"networkProfile,omitempty"`
+ // DiagnosticsProfile - Specifies the boot diagnostic settings state.
Minimum api-version: 2015-06-15.
+ DiagnosticsProfile *DiagnosticsProfile `json:"diagnosticsProfile,omitempty"`
+ // AvailabilitySet - Specifies information about the availability set that the virtual machine should be assigned to. Virtual machines specified in the same availability set are allocated to different nodes to maximize availability. For more information about availability sets, see [Manage the availability of virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-manage-availability?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
For more information on Azure planned maintenance, see [Planned maintenance for virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-planned-maintenance?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
Currently, a VM can only be added to availability set at creation time. An existing VM cannot be added to an availability set.
+ AvailabilitySet *SubResource `json:"availabilitySet,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state, which only appears in the response.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // InstanceView - READ-ONLY; The virtual machine instance view.
+ InstanceView *VirtualMachineInstanceView `json:"instanceView,omitempty"`
+ // LicenseType - Specifies that the image or disk that is being used was licensed on-premises. This element is only used for images that contain the Windows Server operating system.
Possible values are:
Windows_Client
Windows_Server
If this element is included in a request for an update, the value must match the initial value. This value cannot be updated.
For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-hybrid-use-benefit-licensing?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
Minimum api-version: 2015-06-15
+ LicenseType *string `json:"licenseType,omitempty"`
+ // VMID - READ-ONLY; Specifies the VM unique ID which is a 128-bits identifier that is encoded and stored in all Azure IaaS VMs SMBIOS and can be read using platform BIOS commands.
+ VMID *string `json:"vmId,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineProperties.
+func (vmp VirtualMachineProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmp.HardwareProfile != nil {
+ objectMap["hardwareProfile"] = vmp.HardwareProfile
+ }
+ if vmp.StorageProfile != nil {
+ objectMap["storageProfile"] = vmp.StorageProfile
+ }
+ if vmp.OsProfile != nil {
+ objectMap["osProfile"] = vmp.OsProfile
+ }
+ if vmp.NetworkProfile != nil {
+ objectMap["networkProfile"] = vmp.NetworkProfile
+ }
+ if vmp.DiagnosticsProfile != nil {
+ objectMap["diagnosticsProfile"] = vmp.DiagnosticsProfile
+ }
+ if vmp.AvailabilitySet != nil {
+ objectMap["availabilitySet"] = vmp.AvailabilitySet
+ }
+ if vmp.LicenseType != nil {
+ objectMap["licenseType"] = vmp.LicenseType
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineScaleSet describes a Virtual Machine Scale Set.
+type VirtualMachineScaleSet struct {
+ autorest.Response `json:"-"`
+ // Sku - The virtual machine scale set sku.
+ Sku *Sku `json:"sku,omitempty"`
+ // Plan - Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use. In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**.
+ Plan *Plan `json:"plan,omitempty"`
+ *VirtualMachineScaleSetProperties `json:"properties,omitempty"`
+ // Identity - The identity of the virtual machine scale set, if configured.
+ Identity *VirtualMachineScaleSetIdentity `json:"identity,omitempty"`
+ // Zones - The virtual machine scale set zones. NOTE: Availability zones can only be set when you create the scale set.
+ Zones *[]string `json:"zones,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSet.
+func (vmss VirtualMachineScaleSet) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmss.Sku != nil {
+ objectMap["sku"] = vmss.Sku
+ }
+ if vmss.Plan != nil {
+ objectMap["plan"] = vmss.Plan
+ }
+ if vmss.VirtualMachineScaleSetProperties != nil {
+ objectMap["properties"] = vmss.VirtualMachineScaleSetProperties
+ }
+ if vmss.Identity != nil {
+ objectMap["identity"] = vmss.Identity
+ }
+ if vmss.Zones != nil {
+ objectMap["zones"] = vmss.Zones
+ }
+ if vmss.Location != nil {
+ objectMap["location"] = vmss.Location
+ }
+ if vmss.Tags != nil {
+ objectMap["tags"] = vmss.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSet struct.
+func (vmss *VirtualMachineScaleSet) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ vmss.Sku = &sku
+ }
+ case "plan":
+ if v != nil {
+ var plan Plan
+ err = json.Unmarshal(*v, &plan)
+ if err != nil {
+ return err
+ }
+ vmss.Plan = &plan
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetProperties VirtualMachineScaleSetProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetProperties)
+ if err != nil {
+ return err
+ }
+ vmss.VirtualMachineScaleSetProperties = &virtualMachineScaleSetProperties
+ }
+ case "identity":
+ if v != nil {
+ var identity VirtualMachineScaleSetIdentity
+ err = json.Unmarshal(*v, &identity)
+ if err != nil {
+ return err
+ }
+ vmss.Identity = &identity
+ }
+ case "zones":
+ if v != nil {
+ var zones []string
+ err = json.Unmarshal(*v, &zones)
+ if err != nil {
+ return err
+ }
+ vmss.Zones = &zones
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmss.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmss.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vmss.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vmss.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vmss.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetDataDisk describes a virtual machine scale set data disk.
+type VirtualMachineScaleSetDataDisk struct {
+ // Name - The disk name.
+ Name *string `json:"name,omitempty"`
+ // Lun - Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
+ Lun *int32 `json:"lun,omitempty"`
+ // Caching - Specifies the caching requirements.
Possible values are:
**None**
**ReadOnly**
**ReadWrite**
Default: **None for Standard storage. ReadOnly for Premium storage**. Possible values include: 'CachingTypesNone', 'CachingTypesReadOnly', 'CachingTypesReadWrite'
+ Caching CachingTypes `json:"caching,omitempty"`
+ // WriteAcceleratorEnabled - Specifies whether writeAccelerator should be enabled or disabled on the disk.
+ WriteAcceleratorEnabled *bool `json:"writeAcceleratorEnabled,omitempty"`
+ // CreateOption - The create option. Possible values include: 'DiskCreateOptionTypesFromImage', 'DiskCreateOptionTypesEmpty', 'DiskCreateOptionTypesAttach'
+ CreateOption DiskCreateOptionTypes `json:"createOption,omitempty"`
+ // DiskSizeGB - Specifies the size of an empty data disk in gigabytes. This element can be used to overwrite the size of the disk in a virtual machine image.
This value cannot be larger than 1023 GB
+ DiskSizeGB *int32 `json:"diskSizeGB,omitempty"`
+ // ManagedDisk - The managed disk parameters.
+ ManagedDisk *VirtualMachineScaleSetManagedDiskParameters `json:"managedDisk,omitempty"`
+}
+
+// VirtualMachineScaleSetExtension describes a Virtual Machine Scale Set Extension.
+type VirtualMachineScaleSetExtension struct {
+ autorest.Response `json:"-"`
+ // Name - The name of the extension.
+ Name *string `json:"name,omitempty"`
+ *VirtualMachineScaleSetExtensionProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetExtension.
+func (vmsse VirtualMachineScaleSetExtension) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmsse.Name != nil {
+ objectMap["name"] = vmsse.Name
+ }
+ if vmsse.VirtualMachineScaleSetExtensionProperties != nil {
+ objectMap["properties"] = vmsse.VirtualMachineScaleSetExtensionProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetExtension struct.
+func (vmsse *VirtualMachineScaleSetExtension) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmsse.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetExtensionProperties VirtualMachineScaleSetExtensionProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetExtensionProperties)
+ if err != nil {
+ return err
+ }
+ vmsse.VirtualMachineScaleSetExtensionProperties = &virtualMachineScaleSetExtensionProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmsse.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetExtensionListResult the List VM scale set extension operation response.
+type VirtualMachineScaleSetExtensionListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of VM scale set extensions.
+ Value *[]VirtualMachineScaleSetExtension `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of VM scale set extensions. Call ListNext() with this to fetch the next page of VM scale set extensions.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualMachineScaleSetExtensionListResultIterator provides access to a complete listing of
+// VirtualMachineScaleSetExtension values.
+type VirtualMachineScaleSetExtensionListResultIterator struct {
+ i int
+ page VirtualMachineScaleSetExtensionListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualMachineScaleSetExtensionListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetExtensionListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualMachineScaleSetExtensionListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualMachineScaleSetExtensionListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualMachineScaleSetExtensionListResultIterator) Response() VirtualMachineScaleSetExtensionListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualMachineScaleSetExtensionListResultIterator) Value() VirtualMachineScaleSetExtension {
+ if !iter.page.NotDone() {
+ return VirtualMachineScaleSetExtension{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualMachineScaleSetExtensionListResultIterator type.
+func NewVirtualMachineScaleSetExtensionListResultIterator(page VirtualMachineScaleSetExtensionListResultPage) VirtualMachineScaleSetExtensionListResultIterator {
+ return VirtualMachineScaleSetExtensionListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vmsselr VirtualMachineScaleSetExtensionListResult) IsEmpty() bool {
+ return vmsselr.Value == nil || len(*vmsselr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vmsselr VirtualMachineScaleSetExtensionListResult) hasNextLink() bool {
+ return vmsselr.NextLink != nil && len(*vmsselr.NextLink) != 0
+}
+
+// virtualMachineScaleSetExtensionListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vmsselr VirtualMachineScaleSetExtensionListResult) virtualMachineScaleSetExtensionListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vmsselr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vmsselr.NextLink)))
+}
+
+// VirtualMachineScaleSetExtensionListResultPage contains a page of VirtualMachineScaleSetExtension values.
+type VirtualMachineScaleSetExtensionListResultPage struct {
+ fn func(context.Context, VirtualMachineScaleSetExtensionListResult) (VirtualMachineScaleSetExtensionListResult, error)
+ vmsselr VirtualMachineScaleSetExtensionListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualMachineScaleSetExtensionListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetExtensionListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vmsselr)
+ if err != nil {
+ return err
+ }
+ page.vmsselr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualMachineScaleSetExtensionListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualMachineScaleSetExtensionListResultPage) NotDone() bool {
+ return !page.vmsselr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualMachineScaleSetExtensionListResultPage) Response() VirtualMachineScaleSetExtensionListResult {
+ return page.vmsselr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualMachineScaleSetExtensionListResultPage) Values() []VirtualMachineScaleSetExtension {
+ if page.vmsselr.IsEmpty() {
+ return nil
+ }
+ return *page.vmsselr.Value
+}
+
+// Creates a new instance of the VirtualMachineScaleSetExtensionListResultPage type.
+func NewVirtualMachineScaleSetExtensionListResultPage(cur VirtualMachineScaleSetExtensionListResult, getNextPage func(context.Context, VirtualMachineScaleSetExtensionListResult) (VirtualMachineScaleSetExtensionListResult, error)) VirtualMachineScaleSetExtensionListResultPage {
+ return VirtualMachineScaleSetExtensionListResultPage{
+ fn: getNextPage,
+ vmsselr: cur,
+ }
+}
+
+// VirtualMachineScaleSetExtensionProfile describes a virtual machine scale set extension profile.
+type VirtualMachineScaleSetExtensionProfile struct {
+ // Extensions - The virtual machine scale set child extension resources.
+ Extensions *[]VirtualMachineScaleSetExtension `json:"extensions,omitempty"`
+}
+
+// VirtualMachineScaleSetExtensionProperties describes the properties of a Virtual Machine Scale Set
+// Extension.
+type VirtualMachineScaleSetExtensionProperties struct {
+ // ForceUpdateTag - If a value is provided and is different from the previous value, the extension handler will be forced to update even if the extension configuration has not changed.
+ ForceUpdateTag *string `json:"forceUpdateTag,omitempty"`
+ // Publisher - The name of the extension handler publisher.
+ Publisher *string `json:"publisher,omitempty"`
+ // Type - Specifies the type of the extension; an example is "CustomScriptExtension".
+ Type *string `json:"type,omitempty"`
+ // TypeHandlerVersion - Specifies the version of the script handler.
+ TypeHandlerVersion *string `json:"typeHandlerVersion,omitempty"`
+ // AutoUpgradeMinorVersion - Indicates whether the extension should use a newer minor version if one is available at deployment time. Once deployed, however, the extension will not upgrade minor versions unless redeployed, even with this property set to true.
+ AutoUpgradeMinorVersion *bool `json:"autoUpgradeMinorVersion,omitempty"`
+ // Settings - Json formatted public settings for the extension.
+ Settings interface{} `json:"settings,omitempty"`
+ // ProtectedSettings - The extension can contain either protectedSettings or protectedSettingsFromKeyVault or no protected settings at all.
+ ProtectedSettings interface{} `json:"protectedSettings,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state, which only appears in the response.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetExtensionProperties.
+func (vmssep VirtualMachineScaleSetExtensionProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssep.ForceUpdateTag != nil {
+ objectMap["forceUpdateTag"] = vmssep.ForceUpdateTag
+ }
+ if vmssep.Publisher != nil {
+ objectMap["publisher"] = vmssep.Publisher
+ }
+ if vmssep.Type != nil {
+ objectMap["type"] = vmssep.Type
+ }
+ if vmssep.TypeHandlerVersion != nil {
+ objectMap["typeHandlerVersion"] = vmssep.TypeHandlerVersion
+ }
+ if vmssep.AutoUpgradeMinorVersion != nil {
+ objectMap["autoUpgradeMinorVersion"] = vmssep.AutoUpgradeMinorVersion
+ }
+ if vmssep.Settings != nil {
+ objectMap["settings"] = vmssep.Settings
+ }
+ if vmssep.ProtectedSettings != nil {
+ objectMap["protectedSettings"] = vmssep.ProtectedSettings
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineScaleSetExtensionsCreateOrUpdateFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualMachineScaleSetExtensionsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetExtensionsClient) (VirtualMachineScaleSetExtension, error)
+}
+
+// VirtualMachineScaleSetExtensionsDeleteFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualMachineScaleSetExtensionsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetExtensionsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetIdentity identity for the virtual machine scale set.
+type VirtualMachineScaleSetIdentity struct {
+ // PrincipalID - READ-ONLY; The principal id of virtual machine scale set identity. This property will only be provided for a system assigned identity.
+ PrincipalID *string `json:"principalId,omitempty"`
+ // TenantID - READ-ONLY; The tenant id associated with the virtual machine scale set. This property will only be provided for a system assigned identity.
+ TenantID *string `json:"tenantId,omitempty"`
+ // Type - The type of identity used for the virtual machine scale set. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user assigned identities. The type 'None' will remove any identities from the virtual machine scale set. Possible values include: 'ResourceIdentityTypeSystemAssigned', 'ResourceIdentityTypeUserAssigned', 'ResourceIdentityTypeSystemAssignedUserAssigned', 'ResourceIdentityTypeNone'
+ Type ResourceIdentityType `json:"type,omitempty"`
+ // IdentityIds - The list of user identities associated with the virtual machine scale set. The user identity references will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/identities/{identityName}'.
+ IdentityIds *[]string `json:"identityIds,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetIdentity.
+func (vmssi VirtualMachineScaleSetIdentity) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssi.Type != "" {
+ objectMap["type"] = vmssi.Type
+ }
+ if vmssi.IdentityIds != nil {
+ objectMap["identityIds"] = vmssi.IdentityIds
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineScaleSetInstanceView the instance view of a virtual machine scale set.
+type VirtualMachineScaleSetInstanceView struct {
+ autorest.Response `json:"-"`
+ // VirtualMachine - READ-ONLY; The instance view status summary for the virtual machine scale set.
+ VirtualMachine *VirtualMachineScaleSetInstanceViewStatusesSummary `json:"virtualMachine,omitempty"`
+ // Extensions - READ-ONLY; The extensions information.
+ Extensions *[]VirtualMachineScaleSetVMExtensionsSummary `json:"extensions,omitempty"`
+ // Statuses - The resource status information.
+ Statuses *[]InstanceViewStatus `json:"statuses,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetInstanceView.
+func (vmssiv VirtualMachineScaleSetInstanceView) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssiv.Statuses != nil {
+ objectMap["statuses"] = vmssiv.Statuses
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineScaleSetInstanceViewStatusesSummary instance view statuses summary for virtual machines of
+// a virtual machine scale set.
+type VirtualMachineScaleSetInstanceViewStatusesSummary struct {
+ // StatusesSummary - READ-ONLY; The extensions information.
+ StatusesSummary *[]VirtualMachineStatusCodeCount `json:"statusesSummary,omitempty"`
+}
+
+// VirtualMachineScaleSetIPConfiguration describes a virtual machine scale set network profile's IP
+// configuration.
+type VirtualMachineScaleSetIPConfiguration struct {
+ // Name - The IP configuration name.
+ Name *string `json:"name,omitempty"`
+ *VirtualMachineScaleSetIPConfigurationProperties `json:"properties,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetIPConfiguration.
+func (vmssic VirtualMachineScaleSetIPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssic.Name != nil {
+ objectMap["name"] = vmssic.Name
+ }
+ if vmssic.VirtualMachineScaleSetIPConfigurationProperties != nil {
+ objectMap["properties"] = vmssic.VirtualMachineScaleSetIPConfigurationProperties
+ }
+ if vmssic.ID != nil {
+ objectMap["id"] = vmssic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetIPConfiguration struct.
+func (vmssic *VirtualMachineScaleSetIPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmssic.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetIPConfigurationProperties VirtualMachineScaleSetIPConfigurationProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetIPConfigurationProperties)
+ if err != nil {
+ return err
+ }
+ vmssic.VirtualMachineScaleSetIPConfigurationProperties = &virtualMachineScaleSetIPConfigurationProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmssic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetIPConfigurationProperties describes a virtual machine scale set network profile's
+// IP configuration properties.
+type VirtualMachineScaleSetIPConfigurationProperties struct {
+ // Subnet - Specifies the identifier of the subnet.
+ Subnet *APIEntityReference `json:"subnet,omitempty"`
+ // Primary - Specifies the primary network interface in case the virtual machine has more than 1 network interface.
+ Primary *bool `json:"primary,omitempty"`
+ // PublicIPAddressConfiguration - The publicIPAddressConfiguration.
+ PublicIPAddressConfiguration *VirtualMachineScaleSetPublicIPAddressConfiguration `json:"publicIPAddressConfiguration,omitempty"`
+ // PrivateIPAddressVersion - Available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'. Possible values include: 'IPv4', 'IPv6'
+ PrivateIPAddressVersion IPVersion `json:"privateIPAddressVersion,omitempty"`
+ // ApplicationGatewayBackendAddressPools - Specifies an array of references to backend address pools of application gateways. A scale set can reference backend address pools of multiple application gateways. Multiple scale sets cannot use the same application gateway.
+ ApplicationGatewayBackendAddressPools *[]SubResource `json:"applicationGatewayBackendAddressPools,omitempty"`
+ // LoadBalancerBackendAddressPools - Specifies an array of references to backend address pools of load balancers. A scale set can reference backend address pools of one public and one internal load balancer. Multiple scale sets cannot use the same load balancer.
+ LoadBalancerBackendAddressPools *[]SubResource `json:"loadBalancerBackendAddressPools,omitempty"`
+ // LoadBalancerInboundNatPools - Specifies an array of references to inbound Nat pools of the load balancers. A scale set can reference inbound nat pools of one public and one internal load balancer. Multiple scale sets cannot use the same load balancer
+ LoadBalancerInboundNatPools *[]SubResource `json:"loadBalancerInboundNatPools,omitempty"`
+}
+
+// VirtualMachineScaleSetListOSUpgradeHistory list of Virtual Machine Scale Set OS Upgrade History
+// operation response.
+type VirtualMachineScaleSetListOSUpgradeHistory struct {
+ autorest.Response `json:"-"`
+ // Value - The list of OS upgrades performed on the virtual machine scale set.
+ Value *[]UpgradeOperationHistoricalStatusInfo `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of OS Upgrade History. Call ListNext() with this to fetch the next page of history of upgrades.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualMachineScaleSetListOSUpgradeHistoryIterator provides access to a complete listing of
+// UpgradeOperationHistoricalStatusInfo values.
+type VirtualMachineScaleSetListOSUpgradeHistoryIterator struct {
+ i int
+ page VirtualMachineScaleSetListOSUpgradeHistoryPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualMachineScaleSetListOSUpgradeHistoryIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListOSUpgradeHistoryIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualMachineScaleSetListOSUpgradeHistoryIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualMachineScaleSetListOSUpgradeHistoryIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualMachineScaleSetListOSUpgradeHistoryIterator) Response() VirtualMachineScaleSetListOSUpgradeHistory {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualMachineScaleSetListOSUpgradeHistoryIterator) Value() UpgradeOperationHistoricalStatusInfo {
+ if !iter.page.NotDone() {
+ return UpgradeOperationHistoricalStatusInfo{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListOSUpgradeHistoryIterator type.
+func NewVirtualMachineScaleSetListOSUpgradeHistoryIterator(page VirtualMachineScaleSetListOSUpgradeHistoryPage) VirtualMachineScaleSetListOSUpgradeHistoryIterator {
+ return VirtualMachineScaleSetListOSUpgradeHistoryIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vmsslouh VirtualMachineScaleSetListOSUpgradeHistory) IsEmpty() bool {
+ return vmsslouh.Value == nil || len(*vmsslouh.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vmsslouh VirtualMachineScaleSetListOSUpgradeHistory) hasNextLink() bool {
+ return vmsslouh.NextLink != nil && len(*vmsslouh.NextLink) != 0
+}
+
+// virtualMachineScaleSetListOSUpgradeHistoryPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vmsslouh VirtualMachineScaleSetListOSUpgradeHistory) virtualMachineScaleSetListOSUpgradeHistoryPreparer(ctx context.Context) (*http.Request, error) {
+ if !vmsslouh.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vmsslouh.NextLink)))
+}
+
+// VirtualMachineScaleSetListOSUpgradeHistoryPage contains a page of UpgradeOperationHistoricalStatusInfo
+// values.
+type VirtualMachineScaleSetListOSUpgradeHistoryPage struct {
+ fn func(context.Context, VirtualMachineScaleSetListOSUpgradeHistory) (VirtualMachineScaleSetListOSUpgradeHistory, error)
+ vmsslouh VirtualMachineScaleSetListOSUpgradeHistory
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualMachineScaleSetListOSUpgradeHistoryPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListOSUpgradeHistoryPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vmsslouh)
+ if err != nil {
+ return err
+ }
+ page.vmsslouh = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualMachineScaleSetListOSUpgradeHistoryPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualMachineScaleSetListOSUpgradeHistoryPage) NotDone() bool {
+ return !page.vmsslouh.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualMachineScaleSetListOSUpgradeHistoryPage) Response() VirtualMachineScaleSetListOSUpgradeHistory {
+ return page.vmsslouh
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualMachineScaleSetListOSUpgradeHistoryPage) Values() []UpgradeOperationHistoricalStatusInfo {
+ if page.vmsslouh.IsEmpty() {
+ return nil
+ }
+ return *page.vmsslouh.Value
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListOSUpgradeHistoryPage type.
+func NewVirtualMachineScaleSetListOSUpgradeHistoryPage(cur VirtualMachineScaleSetListOSUpgradeHistory, getNextPage func(context.Context, VirtualMachineScaleSetListOSUpgradeHistory) (VirtualMachineScaleSetListOSUpgradeHistory, error)) VirtualMachineScaleSetListOSUpgradeHistoryPage {
+ return VirtualMachineScaleSetListOSUpgradeHistoryPage{
+ fn: getNextPage,
+ vmsslouh: cur,
+ }
+}
+
+// VirtualMachineScaleSetListResult the List Virtual Machine operation response.
+type VirtualMachineScaleSetListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of virtual machine scale sets.
+ Value *[]VirtualMachineScaleSet `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of Virtual Machine Scale Sets. Call ListNext() with this to fetch the next page of VMSS.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualMachineScaleSetListResultIterator provides access to a complete listing of VirtualMachineScaleSet
+// values.
+type VirtualMachineScaleSetListResultIterator struct {
+ i int
+ page VirtualMachineScaleSetListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualMachineScaleSetListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualMachineScaleSetListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualMachineScaleSetListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualMachineScaleSetListResultIterator) Response() VirtualMachineScaleSetListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualMachineScaleSetListResultIterator) Value() VirtualMachineScaleSet {
+ if !iter.page.NotDone() {
+ return VirtualMachineScaleSet{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListResultIterator type.
+func NewVirtualMachineScaleSetListResultIterator(page VirtualMachineScaleSetListResultPage) VirtualMachineScaleSetListResultIterator {
+ return VirtualMachineScaleSetListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vmsslr VirtualMachineScaleSetListResult) IsEmpty() bool {
+ return vmsslr.Value == nil || len(*vmsslr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vmsslr VirtualMachineScaleSetListResult) hasNextLink() bool {
+ return vmsslr.NextLink != nil && len(*vmsslr.NextLink) != 0
+}
+
+// virtualMachineScaleSetListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vmsslr VirtualMachineScaleSetListResult) virtualMachineScaleSetListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vmsslr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vmsslr.NextLink)))
+}
+
+// VirtualMachineScaleSetListResultPage contains a page of VirtualMachineScaleSet values.
+type VirtualMachineScaleSetListResultPage struct {
+ fn func(context.Context, VirtualMachineScaleSetListResult) (VirtualMachineScaleSetListResult, error)
+ vmsslr VirtualMachineScaleSetListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualMachineScaleSetListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vmsslr)
+ if err != nil {
+ return err
+ }
+ page.vmsslr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualMachineScaleSetListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualMachineScaleSetListResultPage) NotDone() bool {
+ return !page.vmsslr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualMachineScaleSetListResultPage) Response() VirtualMachineScaleSetListResult {
+ return page.vmsslr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualMachineScaleSetListResultPage) Values() []VirtualMachineScaleSet {
+ if page.vmsslr.IsEmpty() {
+ return nil
+ }
+ return *page.vmsslr.Value
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListResultPage type.
+func NewVirtualMachineScaleSetListResultPage(cur VirtualMachineScaleSetListResult, getNextPage func(context.Context, VirtualMachineScaleSetListResult) (VirtualMachineScaleSetListResult, error)) VirtualMachineScaleSetListResultPage {
+ return VirtualMachineScaleSetListResultPage{
+ fn: getNextPage,
+ vmsslr: cur,
+ }
+}
+
+// VirtualMachineScaleSetListSkusResult the Virtual Machine Scale Set List Skus operation response.
+type VirtualMachineScaleSetListSkusResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of skus available for the virtual machine scale set.
+ Value *[]VirtualMachineScaleSetSku `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of Virtual Machine Scale Set Skus. Call ListNext() with this to fetch the next page of VMSS Skus.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualMachineScaleSetListSkusResultIterator provides access to a complete listing of
+// VirtualMachineScaleSetSku values.
+type VirtualMachineScaleSetListSkusResultIterator struct {
+ i int
+ page VirtualMachineScaleSetListSkusResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualMachineScaleSetListSkusResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListSkusResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualMachineScaleSetListSkusResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualMachineScaleSetListSkusResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualMachineScaleSetListSkusResultIterator) Response() VirtualMachineScaleSetListSkusResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualMachineScaleSetListSkusResultIterator) Value() VirtualMachineScaleSetSku {
+ if !iter.page.NotDone() {
+ return VirtualMachineScaleSetSku{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListSkusResultIterator type.
+func NewVirtualMachineScaleSetListSkusResultIterator(page VirtualMachineScaleSetListSkusResultPage) VirtualMachineScaleSetListSkusResultIterator {
+ return VirtualMachineScaleSetListSkusResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vmsslsr VirtualMachineScaleSetListSkusResult) IsEmpty() bool {
+ return vmsslsr.Value == nil || len(*vmsslsr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vmsslsr VirtualMachineScaleSetListSkusResult) hasNextLink() bool {
+ return vmsslsr.NextLink != nil && len(*vmsslsr.NextLink) != 0
+}
+
+// virtualMachineScaleSetListSkusResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vmsslsr VirtualMachineScaleSetListSkusResult) virtualMachineScaleSetListSkusResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vmsslsr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vmsslsr.NextLink)))
+}
+
+// VirtualMachineScaleSetListSkusResultPage contains a page of VirtualMachineScaleSetSku values.
+type VirtualMachineScaleSetListSkusResultPage struct {
+ fn func(context.Context, VirtualMachineScaleSetListSkusResult) (VirtualMachineScaleSetListSkusResult, error)
+ vmsslsr VirtualMachineScaleSetListSkusResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualMachineScaleSetListSkusResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListSkusResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vmsslsr)
+ if err != nil {
+ return err
+ }
+ page.vmsslsr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualMachineScaleSetListSkusResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualMachineScaleSetListSkusResultPage) NotDone() bool {
+ return !page.vmsslsr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualMachineScaleSetListSkusResultPage) Response() VirtualMachineScaleSetListSkusResult {
+ return page.vmsslsr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualMachineScaleSetListSkusResultPage) Values() []VirtualMachineScaleSetSku {
+ if page.vmsslsr.IsEmpty() {
+ return nil
+ }
+ return *page.vmsslsr.Value
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListSkusResultPage type.
+func NewVirtualMachineScaleSetListSkusResultPage(cur VirtualMachineScaleSetListSkusResult, getNextPage func(context.Context, VirtualMachineScaleSetListSkusResult) (VirtualMachineScaleSetListSkusResult, error)) VirtualMachineScaleSetListSkusResultPage {
+ return VirtualMachineScaleSetListSkusResultPage{
+ fn: getNextPage,
+ vmsslsr: cur,
+ }
+}
+
+// VirtualMachineScaleSetListWithLinkResult the List Virtual Machine operation response.
+type VirtualMachineScaleSetListWithLinkResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of virtual machine scale sets.
+ Value *[]VirtualMachineScaleSet `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of Virtual Machine Scale Sets. Call ListNext() with this to fetch the next page of Virtual Machine Scale Sets.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualMachineScaleSetListWithLinkResultIterator provides access to a complete listing of
+// VirtualMachineScaleSet values.
+type VirtualMachineScaleSetListWithLinkResultIterator struct {
+ i int
+ page VirtualMachineScaleSetListWithLinkResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualMachineScaleSetListWithLinkResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListWithLinkResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualMachineScaleSetListWithLinkResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualMachineScaleSetListWithLinkResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualMachineScaleSetListWithLinkResultIterator) Response() VirtualMachineScaleSetListWithLinkResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualMachineScaleSetListWithLinkResultIterator) Value() VirtualMachineScaleSet {
+ if !iter.page.NotDone() {
+ return VirtualMachineScaleSet{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListWithLinkResultIterator type.
+func NewVirtualMachineScaleSetListWithLinkResultIterator(page VirtualMachineScaleSetListWithLinkResultPage) VirtualMachineScaleSetListWithLinkResultIterator {
+ return VirtualMachineScaleSetListWithLinkResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vmsslwlr VirtualMachineScaleSetListWithLinkResult) IsEmpty() bool {
+ return vmsslwlr.Value == nil || len(*vmsslwlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vmsslwlr VirtualMachineScaleSetListWithLinkResult) hasNextLink() bool {
+ return vmsslwlr.NextLink != nil && len(*vmsslwlr.NextLink) != 0
+}
+
+// virtualMachineScaleSetListWithLinkResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vmsslwlr VirtualMachineScaleSetListWithLinkResult) virtualMachineScaleSetListWithLinkResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vmsslwlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vmsslwlr.NextLink)))
+}
+
+// VirtualMachineScaleSetListWithLinkResultPage contains a page of VirtualMachineScaleSet values.
+type VirtualMachineScaleSetListWithLinkResultPage struct {
+ fn func(context.Context, VirtualMachineScaleSetListWithLinkResult) (VirtualMachineScaleSetListWithLinkResult, error)
+ vmsslwlr VirtualMachineScaleSetListWithLinkResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualMachineScaleSetListWithLinkResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetListWithLinkResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vmsslwlr)
+ if err != nil {
+ return err
+ }
+ page.vmsslwlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualMachineScaleSetListWithLinkResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualMachineScaleSetListWithLinkResultPage) NotDone() bool {
+ return !page.vmsslwlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualMachineScaleSetListWithLinkResultPage) Response() VirtualMachineScaleSetListWithLinkResult {
+ return page.vmsslwlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualMachineScaleSetListWithLinkResultPage) Values() []VirtualMachineScaleSet {
+ if page.vmsslwlr.IsEmpty() {
+ return nil
+ }
+ return *page.vmsslwlr.Value
+}
+
+// Creates a new instance of the VirtualMachineScaleSetListWithLinkResultPage type.
+func NewVirtualMachineScaleSetListWithLinkResultPage(cur VirtualMachineScaleSetListWithLinkResult, getNextPage func(context.Context, VirtualMachineScaleSetListWithLinkResult) (VirtualMachineScaleSetListWithLinkResult, error)) VirtualMachineScaleSetListWithLinkResultPage {
+ return VirtualMachineScaleSetListWithLinkResultPage{
+ fn: getNextPage,
+ vmsslwlr: cur,
+ }
+}
+
+// VirtualMachineScaleSetManagedDiskParameters describes the parameters of a ScaleSet managed disk.
+type VirtualMachineScaleSetManagedDiskParameters struct {
+ // StorageAccountType - Specifies the storage account type for the managed disk. Possible values are: Standard_LRS or Premium_LRS. Possible values include: 'StandardLRS', 'PremiumLRS'
+ StorageAccountType StorageAccountTypes `json:"storageAccountType,omitempty"`
+}
+
+// VirtualMachineScaleSetNetworkConfiguration describes a virtual machine scale set network profile's
+// network configurations.
+type VirtualMachineScaleSetNetworkConfiguration struct {
+ // Name - The network configuration name.
+ Name *string `json:"name,omitempty"`
+ *VirtualMachineScaleSetNetworkConfigurationProperties `json:"properties,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetNetworkConfiguration.
+func (vmssnc VirtualMachineScaleSetNetworkConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssnc.Name != nil {
+ objectMap["name"] = vmssnc.Name
+ }
+ if vmssnc.VirtualMachineScaleSetNetworkConfigurationProperties != nil {
+ objectMap["properties"] = vmssnc.VirtualMachineScaleSetNetworkConfigurationProperties
+ }
+ if vmssnc.ID != nil {
+ objectMap["id"] = vmssnc.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetNetworkConfiguration struct.
+func (vmssnc *VirtualMachineScaleSetNetworkConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmssnc.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetNetworkConfigurationProperties VirtualMachineScaleSetNetworkConfigurationProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetNetworkConfigurationProperties)
+ if err != nil {
+ return err
+ }
+ vmssnc.VirtualMachineScaleSetNetworkConfigurationProperties = &virtualMachineScaleSetNetworkConfigurationProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmssnc.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetNetworkConfigurationDNSSettings describes a virtual machines scale sets network
+// configuration's DNS settings.
+type VirtualMachineScaleSetNetworkConfigurationDNSSettings struct {
+ // DNSServers - List of DNS servers IP addresses
+ DNSServers *[]string `json:"dnsServers,omitempty"`
+}
+
+// VirtualMachineScaleSetNetworkConfigurationProperties describes a virtual machine scale set network
+// profile's IP configuration.
+type VirtualMachineScaleSetNetworkConfigurationProperties struct {
+ // Primary - Specifies the primary network interface in case the virtual machine has more than 1 network interface.
+ Primary *bool `json:"primary,omitempty"`
+ // EnableAcceleratedNetworking - Specifies whether the network interface is accelerated networking-enabled.
+ EnableAcceleratedNetworking *bool `json:"enableAcceleratedNetworking,omitempty"`
+ // NetworkSecurityGroup - The network security group.
+ NetworkSecurityGroup *SubResource `json:"networkSecurityGroup,omitempty"`
+ // DNSSettings - The dns settings to be applied on the network interfaces.
+ DNSSettings *VirtualMachineScaleSetNetworkConfigurationDNSSettings `json:"dnsSettings,omitempty"`
+ // IPConfigurations - Specifies the IP configurations of the network interface.
+ IPConfigurations *[]VirtualMachineScaleSetIPConfiguration `json:"ipConfigurations,omitempty"`
+ // EnableIPForwarding - Whether IP forwarding enabled on this NIC.
+ EnableIPForwarding *bool `json:"enableIPForwarding,omitempty"`
+}
+
+// VirtualMachineScaleSetNetworkProfile describes a virtual machine scale set network profile.
+type VirtualMachineScaleSetNetworkProfile struct {
+ // HealthProbe - A reference to a load balancer probe used to determine the health of an instance in the virtual machine scale set. The reference will be in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}'.
+ HealthProbe *APIEntityReference `json:"healthProbe,omitempty"`
+ // NetworkInterfaceConfigurations - The list of network configurations.
+ NetworkInterfaceConfigurations *[]VirtualMachineScaleSetNetworkConfiguration `json:"networkInterfaceConfigurations,omitempty"`
+}
+
+// VirtualMachineScaleSetOSDisk describes a virtual machine scale set operating system disk.
+type VirtualMachineScaleSetOSDisk struct {
+ // Name - The disk name.
+ Name *string `json:"name,omitempty"`
+ // Caching - Specifies the caching requirements.
Possible values are:
**None**
**ReadOnly**
**ReadWrite**
Default: **None for Standard storage. ReadOnly for Premium storage**. Possible values include: 'CachingTypesNone', 'CachingTypesReadOnly', 'CachingTypesReadWrite'
+ Caching CachingTypes `json:"caching,omitempty"`
+ // WriteAcceleratorEnabled - Specifies whether writeAccelerator should be enabled or disabled on the disk.
+ WriteAcceleratorEnabled *bool `json:"writeAcceleratorEnabled,omitempty"`
+ // CreateOption - Specifies how the virtual machines in the scale set should be created.
The only allowed value is: **FromImage** \u2013 This value is used when you are using an image to create the virtual machine. If you are using a platform image, you also use the imageReference element described above. If you are using a marketplace image, you also use the plan element previously described. Possible values include: 'DiskCreateOptionTypesFromImage', 'DiskCreateOptionTypesEmpty', 'DiskCreateOptionTypesAttach'
+ CreateOption DiskCreateOptionTypes `json:"createOption,omitempty"`
+ // OsType - This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD.
Possible values are:
**Windows**
**Linux**. Possible values include: 'Windows', 'Linux'
+ OsType OperatingSystemTypes `json:"osType,omitempty"`
+ // Image - Specifies information about the unmanaged user image to base the scale set on.
+ Image *VirtualHardDisk `json:"image,omitempty"`
+ // VhdContainers - Specifies the container urls that are used to store operating system disks for the scale set.
+ VhdContainers *[]string `json:"vhdContainers,omitempty"`
+ // ManagedDisk - The managed disk parameters.
+ ManagedDisk *VirtualMachineScaleSetManagedDiskParameters `json:"managedDisk,omitempty"`
+}
+
+// VirtualMachineScaleSetOSProfile describes a virtual machine scale set OS profile.
+type VirtualMachineScaleSetOSProfile struct {
+ // ComputerNamePrefix - Specifies the computer name prefix for all of the virtual machines in the scale set. Computer name prefixes must be 1 to 15 characters long.
+ ComputerNamePrefix *string `json:"computerNamePrefix,omitempty"`
+ // AdminUsername - Specifies the name of the administrator account.
**Windows-only restriction:** Cannot end in "."
**Disallowed values:** "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest", "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5".
**Minimum-length (Linux):** 1 character
**Max-length (Linux):** 64 characters
**Max-length (Windows):** 20 characters
For root access to the Linux VM, see [Using root privileges on Linux virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-use-root-privileges?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
For a list of built-in system users on Linux that should not be used in this field, see [Selecting User Names for Linux on Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-usernames?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
+ AdminUsername *string `json:"adminUsername,omitempty"`
+ // AdminPassword - Specifies the password of the administrator account.
**Minimum-length (Windows):** 8 characters
**Minimum-length (Linux):** 6 characters
**Max-length (Windows):** 123 characters
**Max-length (Linux):** 72 characters
**Complexity requirements:** 3 out of 4 conditions below need to be fulfilled
Has lower characters
Has upper characters
Has a digit
Has a special character (Regex match [\W_])
**Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1", "Password22", "iloveyou!"
For resetting the password, see [How to reset the Remote Desktop service or its login password in a Windows VM](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-reset-rdp?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
For resetting root password, see [Manage users, SSH, and check or repair disks on Azure Linux VMs using the VMAccess Extension](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-vmaccess-extension?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#reset-root-password)
+ AdminPassword *string `json:"adminPassword,omitempty"`
+ // CustomData - Specifies a base-64 encoded string of custom data. The base-64 encoded string is decoded to a binary array that is saved as a file on the Virtual Machine. The maximum length of the binary array is 65535 bytes.
For using cloud-init for your VM, see [Using cloud-init to customize a Linux VM during creation](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-using-cloud-init?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
+ CustomData *string `json:"customData,omitempty"`
+ // WindowsConfiguration - Specifies Windows operating system settings on the virtual machine.
+ WindowsConfiguration *WindowsConfiguration `json:"windowsConfiguration,omitempty"`
+ // LinuxConfiguration - Specifies the Linux operating system settings on the virtual machine.
For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-endorsed-distros?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json)
For running non-endorsed distributions, see [Information for Non-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-linux-create-upload-generic?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json).
+ LinuxConfiguration *LinuxConfiguration `json:"linuxConfiguration,omitempty"`
+ // Secrets - Specifies set of certificates that should be installed onto the virtual machines in the scale set.
+ Secrets *[]VaultSecretGroup `json:"secrets,omitempty"`
+}
+
+// VirtualMachineScaleSetProperties describes the properties of a Virtual Machine Scale Set.
+type VirtualMachineScaleSetProperties struct {
+ // UpgradePolicy - The upgrade policy.
+ UpgradePolicy *UpgradePolicy `json:"upgradePolicy,omitempty"`
+ // VirtualMachineProfile - The virtual machine profile.
+ VirtualMachineProfile *VirtualMachineScaleSetVMProfile `json:"virtualMachineProfile,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state, which only appears in the response.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // Overprovision - Specifies whether the Virtual Machine Scale Set should be overprovisioned.
+ Overprovision *bool `json:"overprovision,omitempty"`
+ // UniqueID - READ-ONLY; Specifies the ID which uniquely identifies a Virtual Machine Scale Set.
+ UniqueID *string `json:"uniqueId,omitempty"`
+ // SinglePlacementGroup - When true this limits the scale set to a single placement group, of max size 100 virtual machines.
+ SinglePlacementGroup *bool `json:"singlePlacementGroup,omitempty"`
+ // ZoneBalance - Whether to force strictly even Virtual Machine distribution cross x-zones in case there is zone outage.
+ ZoneBalance *bool `json:"zoneBalance,omitempty"`
+ // PlatformFaultDomainCount - Fault Domain count for each placement group.
+ PlatformFaultDomainCount *int32 `json:"platformFaultDomainCount,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetProperties.
+func (vmssp VirtualMachineScaleSetProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssp.UpgradePolicy != nil {
+ objectMap["upgradePolicy"] = vmssp.UpgradePolicy
+ }
+ if vmssp.VirtualMachineProfile != nil {
+ objectMap["virtualMachineProfile"] = vmssp.VirtualMachineProfile
+ }
+ if vmssp.Overprovision != nil {
+ objectMap["overprovision"] = vmssp.Overprovision
+ }
+ if vmssp.SinglePlacementGroup != nil {
+ objectMap["singlePlacementGroup"] = vmssp.SinglePlacementGroup
+ }
+ if vmssp.ZoneBalance != nil {
+ objectMap["zoneBalance"] = vmssp.ZoneBalance
+ }
+ if vmssp.PlatformFaultDomainCount != nil {
+ objectMap["platformFaultDomainCount"] = vmssp.PlatformFaultDomainCount
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineScaleSetPublicIPAddressConfiguration describes a virtual machines scale set IP
+// Configuration's PublicIPAddress configuration
+type VirtualMachineScaleSetPublicIPAddressConfiguration struct {
+ // Name - The publicIP address configuration name.
+ Name *string `json:"name,omitempty"`
+ *VirtualMachineScaleSetPublicIPAddressConfigurationProperties `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetPublicIPAddressConfiguration.
+func (vmsspiac VirtualMachineScaleSetPublicIPAddressConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmsspiac.Name != nil {
+ objectMap["name"] = vmsspiac.Name
+ }
+ if vmsspiac.VirtualMachineScaleSetPublicIPAddressConfigurationProperties != nil {
+ objectMap["properties"] = vmsspiac.VirtualMachineScaleSetPublicIPAddressConfigurationProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetPublicIPAddressConfiguration struct.
+func (vmsspiac *VirtualMachineScaleSetPublicIPAddressConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmsspiac.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetPublicIPAddressConfigurationProperties VirtualMachineScaleSetPublicIPAddressConfigurationProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetPublicIPAddressConfigurationProperties)
+ if err != nil {
+ return err
+ }
+ vmsspiac.VirtualMachineScaleSetPublicIPAddressConfigurationProperties = &virtualMachineScaleSetPublicIPAddressConfigurationProperties
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings describes a virtual machines scale sets
+// network configuration's DNS settings.
+type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings struct {
+ // DomainNameLabel - The Domain name label.The concatenation of the domain name label and vm index will be the domain name labels of the PublicIPAddress resources that will be created
+ DomainNameLabel *string `json:"domainNameLabel,omitempty"`
+}
+
+// VirtualMachineScaleSetPublicIPAddressConfigurationProperties describes a virtual machines scale set IP
+// Configuration's PublicIPAddress configuration
+type VirtualMachineScaleSetPublicIPAddressConfigurationProperties struct {
+ // IdleTimeoutInMinutes - The idle timeout of the public IP address.
+ IdleTimeoutInMinutes *int32 `json:"idleTimeoutInMinutes,omitempty"`
+ // DNSSettings - The dns settings to be applied on the publicIP addresses .
+ DNSSettings *VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings `json:"dnsSettings,omitempty"`
+}
+
+// VirtualMachineScaleSetRollingUpgradesCancelFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualMachineScaleSetRollingUpgradesCancelFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetRollingUpgradesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture an abstraction for monitoring and retrieving
+// the results of a long-running operation.
+type VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetRollingUpgradesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualMachineScaleSetsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (VirtualMachineScaleSet, error)
+}
+
+// VirtualMachineScaleSetsDeallocateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsDeallocateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsDeleteInstancesFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualMachineScaleSetsDeleteInstancesFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetSku describes an available virtual machine scale set sku.
+type VirtualMachineScaleSetSku struct {
+ // ResourceType - READ-ONLY; The type of resource the sku applies to.
+ ResourceType *string `json:"resourceType,omitempty"`
+ // Sku - READ-ONLY; The Sku.
+ Sku *Sku `json:"sku,omitempty"`
+ // Capacity - READ-ONLY; Specifies the number of virtual machines in the scale set.
+ Capacity *VirtualMachineScaleSetSkuCapacity `json:"capacity,omitempty"`
+}
+
+// VirtualMachineScaleSetSkuCapacity describes scaling information of a sku.
+type VirtualMachineScaleSetSkuCapacity struct {
+ // Minimum - READ-ONLY; The minimum capacity.
+ Minimum *int64 `json:"minimum,omitempty"`
+ // Maximum - READ-ONLY; The maximum capacity that can be set.
+ Maximum *int64 `json:"maximum,omitempty"`
+ // DefaultCapacity - READ-ONLY; The default capacity.
+ DefaultCapacity *int64 `json:"defaultCapacity,omitempty"`
+ // ScaleType - READ-ONLY; The scale type applicable to the sku. Possible values include: 'VirtualMachineScaleSetSkuScaleTypeAutomatic', 'VirtualMachineScaleSetSkuScaleTypeNone'
+ ScaleType VirtualMachineScaleSetSkuScaleType `json:"scaleType,omitempty"`
+}
+
+// VirtualMachineScaleSetsPerformMaintenanceFuture an abstraction for monitoring and retrieving the results
+// of a long-running operation.
+type VirtualMachineScaleSetsPerformMaintenanceFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsPowerOffFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsPowerOffFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsRedeployFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsRedeployFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsReimageAllFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsReimageAllFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsReimageFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsReimageFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsRestartFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsRestartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetsStartFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsStartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetStorageProfile describes a virtual machine scale set storage profile.
+type VirtualMachineScaleSetStorageProfile struct {
+ // ImageReference - Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations.
+ ImageReference *ImageReference `json:"imageReference,omitempty"`
+ // OsDisk - Specifies information about the operating system disk used by the virtual machines in the scale set.
For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+ OsDisk *VirtualMachineScaleSetOSDisk `json:"osDisk,omitempty"`
+ // DataDisks - Specifies the parameters that are used to add data disks to the virtual machines in the scale set.
For more information about disks, see [About disks and VHDs for Azure virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-about-disks-vhds?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
+ DataDisks *[]VirtualMachineScaleSetDataDisk `json:"dataDisks,omitempty"`
+}
+
+// VirtualMachineScaleSetsUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetsUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (VirtualMachineScaleSet, error)
+}
+
+// VirtualMachineScaleSetsUpdateInstancesFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualMachineScaleSetsUpdateInstancesFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetUpdate describes a Virtual Machine Scale Set.
+type VirtualMachineScaleSetUpdate struct {
+ // Sku - The virtual machine scale set sku.
+ Sku *Sku `json:"sku,omitempty"`
+ // Plan - The purchase plan when deploying a virtual machine scale set from VM Marketplace images.
+ Plan *Plan `json:"plan,omitempty"`
+ *VirtualMachineScaleSetUpdateProperties `json:"properties,omitempty"`
+ // Identity - The identity of the virtual machine scale set, if configured.
+ Identity *VirtualMachineScaleSetIdentity `json:"identity,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetUpdate.
+func (vmssu VirtualMachineScaleSetUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssu.Sku != nil {
+ objectMap["sku"] = vmssu.Sku
+ }
+ if vmssu.Plan != nil {
+ objectMap["plan"] = vmssu.Plan
+ }
+ if vmssu.VirtualMachineScaleSetUpdateProperties != nil {
+ objectMap["properties"] = vmssu.VirtualMachineScaleSetUpdateProperties
+ }
+ if vmssu.Identity != nil {
+ objectMap["identity"] = vmssu.Identity
+ }
+ if vmssu.Tags != nil {
+ objectMap["tags"] = vmssu.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetUpdate struct.
+func (vmssu *VirtualMachineScaleSetUpdate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ vmssu.Sku = &sku
+ }
+ case "plan":
+ if v != nil {
+ var plan Plan
+ err = json.Unmarshal(*v, &plan)
+ if err != nil {
+ return err
+ }
+ vmssu.Plan = &plan
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetUpdateProperties VirtualMachineScaleSetUpdateProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetUpdateProperties)
+ if err != nil {
+ return err
+ }
+ vmssu.VirtualMachineScaleSetUpdateProperties = &virtualMachineScaleSetUpdateProperties
+ }
+ case "identity":
+ if v != nil {
+ var identity VirtualMachineScaleSetIdentity
+ err = json.Unmarshal(*v, &identity)
+ if err != nil {
+ return err
+ }
+ vmssu.Identity = &identity
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vmssu.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetUpdateIPConfiguration describes a virtual machine scale set network profile's IP
+// configuration.
+type VirtualMachineScaleSetUpdateIPConfiguration struct {
+ // Name - The IP configuration name.
+ Name *string `json:"name,omitempty"`
+ *VirtualMachineScaleSetUpdateIPConfigurationProperties `json:"properties,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetUpdateIPConfiguration.
+func (vmssuic VirtualMachineScaleSetUpdateIPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssuic.Name != nil {
+ objectMap["name"] = vmssuic.Name
+ }
+ if vmssuic.VirtualMachineScaleSetUpdateIPConfigurationProperties != nil {
+ objectMap["properties"] = vmssuic.VirtualMachineScaleSetUpdateIPConfigurationProperties
+ }
+ if vmssuic.ID != nil {
+ objectMap["id"] = vmssuic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetUpdateIPConfiguration struct.
+func (vmssuic *VirtualMachineScaleSetUpdateIPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmssuic.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetUpdateIPConfigurationProperties VirtualMachineScaleSetUpdateIPConfigurationProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetUpdateIPConfigurationProperties)
+ if err != nil {
+ return err
+ }
+ vmssuic.VirtualMachineScaleSetUpdateIPConfigurationProperties = &virtualMachineScaleSetUpdateIPConfigurationProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmssuic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetUpdateIPConfigurationProperties describes a virtual machine scale set network
+// profile's IP configuration properties. NOTE: The subnet of a scale set may be modified as long as the
+// original subnet and the new subnet are in the same virtual network.
+type VirtualMachineScaleSetUpdateIPConfigurationProperties struct {
+ // Subnet - The subnet.
+ Subnet *APIEntityReference `json:"subnet,omitempty"`
+ // Primary - Specifies the primary IP Configuration in case the network interface has more than one IP Configuration.
+ Primary *bool `json:"primary,omitempty"`
+ // PublicIPAddressConfiguration - The publicIPAddressConfiguration.
+ PublicIPAddressConfiguration *VirtualMachineScaleSetUpdatePublicIPAddressConfiguration `json:"publicIPAddressConfiguration,omitempty"`
+ // PrivateIPAddressVersion - Available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'. Possible values include: 'IPv4', 'IPv6'
+ PrivateIPAddressVersion IPVersion `json:"privateIPAddressVersion,omitempty"`
+ // ApplicationGatewayBackendAddressPools - The application gateway backend address pools.
+ ApplicationGatewayBackendAddressPools *[]SubResource `json:"applicationGatewayBackendAddressPools,omitempty"`
+ // LoadBalancerBackendAddressPools - The load balancer backend address pools.
+ LoadBalancerBackendAddressPools *[]SubResource `json:"loadBalancerBackendAddressPools,omitempty"`
+ // LoadBalancerInboundNatPools - The load balancer inbound nat pools.
+ LoadBalancerInboundNatPools *[]SubResource `json:"loadBalancerInboundNatPools,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdateNetworkConfiguration describes a virtual machine scale set network profile's
+// network configurations.
+type VirtualMachineScaleSetUpdateNetworkConfiguration struct {
+ // Name - The network configuration name.
+ Name *string `json:"name,omitempty"`
+ *VirtualMachineScaleSetUpdateNetworkConfigurationProperties `json:"properties,omitempty"`
+ // ID - Resource Id
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetUpdateNetworkConfiguration.
+func (vmssunc VirtualMachineScaleSetUpdateNetworkConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssunc.Name != nil {
+ objectMap["name"] = vmssunc.Name
+ }
+ if vmssunc.VirtualMachineScaleSetUpdateNetworkConfigurationProperties != nil {
+ objectMap["properties"] = vmssunc.VirtualMachineScaleSetUpdateNetworkConfigurationProperties
+ }
+ if vmssunc.ID != nil {
+ objectMap["id"] = vmssunc.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetUpdateNetworkConfiguration struct.
+func (vmssunc *VirtualMachineScaleSetUpdateNetworkConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmssunc.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetUpdateNetworkConfigurationProperties VirtualMachineScaleSetUpdateNetworkConfigurationProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetUpdateNetworkConfigurationProperties)
+ if err != nil {
+ return err
+ }
+ vmssunc.VirtualMachineScaleSetUpdateNetworkConfigurationProperties = &virtualMachineScaleSetUpdateNetworkConfigurationProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmssunc.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetUpdateNetworkConfigurationProperties describes a virtual machine scale set
+// updatable network profile's IP configuration.Use this object for updating network profile's IP
+// Configuration.
+type VirtualMachineScaleSetUpdateNetworkConfigurationProperties struct {
+ // Primary - Whether this is a primary NIC on a virtual machine.
+ Primary *bool `json:"primary,omitempty"`
+ // EnableAcceleratedNetworking - Specifies whether the network interface is accelerated networking-enabled.
+ EnableAcceleratedNetworking *bool `json:"enableAcceleratedNetworking,omitempty"`
+ // NetworkSecurityGroup - The network security group.
+ NetworkSecurityGroup *SubResource `json:"networkSecurityGroup,omitempty"`
+ // DNSSettings - The dns settings to be applied on the network interfaces.
+ DNSSettings *VirtualMachineScaleSetNetworkConfigurationDNSSettings `json:"dnsSettings,omitempty"`
+ // IPConfigurations - The virtual machine scale set IP Configuration.
+ IPConfigurations *[]VirtualMachineScaleSetUpdateIPConfiguration `json:"ipConfigurations,omitempty"`
+ // EnableIPForwarding - Whether IP forwarding enabled on this NIC.
+ EnableIPForwarding *bool `json:"enableIPForwarding,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdateNetworkProfile describes a virtual machine scale set network profile.
+type VirtualMachineScaleSetUpdateNetworkProfile struct {
+ // NetworkInterfaceConfigurations - The list of network configurations.
+ NetworkInterfaceConfigurations *[]VirtualMachineScaleSetUpdateNetworkConfiguration `json:"networkInterfaceConfigurations,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdateOSDisk describes virtual machine scale set operating system disk Update
+// Object. This should be used for Updating VMSS OS Disk.
+type VirtualMachineScaleSetUpdateOSDisk struct {
+ // Caching - The caching type. Possible values include: 'CachingTypesNone', 'CachingTypesReadOnly', 'CachingTypesReadWrite'
+ Caching CachingTypes `json:"caching,omitempty"`
+ // WriteAcceleratorEnabled - Specifies whether writeAccelerator should be enabled or disabled on the disk.
+ WriteAcceleratorEnabled *bool `json:"writeAcceleratorEnabled,omitempty"`
+ // Image - The Source User Image VirtualHardDisk. This VirtualHardDisk will be copied before using it to attach to the Virtual Machine. If SourceImage is provided, the destination VirtualHardDisk should not exist.
+ Image *VirtualHardDisk `json:"image,omitempty"`
+ // VhdContainers - The list of virtual hard disk container uris.
+ VhdContainers *[]string `json:"vhdContainers,omitempty"`
+ // ManagedDisk - The managed disk parameters.
+ ManagedDisk *VirtualMachineScaleSetManagedDiskParameters `json:"managedDisk,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdateOSProfile describes a virtual machine scale set OS profile.
+type VirtualMachineScaleSetUpdateOSProfile struct {
+ // CustomData - A base-64 encoded string of custom data.
+ CustomData *string `json:"customData,omitempty"`
+ // WindowsConfiguration - The Windows Configuration of the OS profile.
+ WindowsConfiguration *WindowsConfiguration `json:"windowsConfiguration,omitempty"`
+ // LinuxConfiguration - The Linux Configuration of the OS profile.
+ LinuxConfiguration *LinuxConfiguration `json:"linuxConfiguration,omitempty"`
+ // Secrets - The List of certificates for addition to the VM.
+ Secrets *[]VaultSecretGroup `json:"secrets,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdateProperties describes the properties of a Virtual Machine Scale Set.
+type VirtualMachineScaleSetUpdateProperties struct {
+ // UpgradePolicy - The upgrade policy.
+ UpgradePolicy *UpgradePolicy `json:"upgradePolicy,omitempty"`
+ // VirtualMachineProfile - The virtual machine profile.
+ VirtualMachineProfile *VirtualMachineScaleSetUpdateVMProfile `json:"virtualMachineProfile,omitempty"`
+ // Overprovision - Specifies whether the Virtual Machine Scale Set should be overprovisioned.
+ Overprovision *bool `json:"overprovision,omitempty"`
+ // SinglePlacementGroup - When true this limits the scale set to a single placement group, of max size 100 virtual machines. NOTE: If singlePlacementGroup is true, it may be modified to false. However, if singlePlacementGroup is false, it may not be modified to true.
+ SinglePlacementGroup *bool `json:"singlePlacementGroup,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdatePublicIPAddressConfiguration describes a virtual machines scale set IP
+// Configuration's PublicIPAddress configuration
+type VirtualMachineScaleSetUpdatePublicIPAddressConfiguration struct {
+ // Name - The publicIP address configuration name.
+ Name *string `json:"name,omitempty"`
+ *VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetUpdatePublicIPAddressConfiguration.
+func (vmssupiac VirtualMachineScaleSetUpdatePublicIPAddressConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssupiac.Name != nil {
+ objectMap["name"] = vmssupiac.Name
+ }
+ if vmssupiac.VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties != nil {
+ objectMap["properties"] = vmssupiac.VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetUpdatePublicIPAddressConfiguration struct.
+func (vmssupiac *VirtualMachineScaleSetUpdatePublicIPAddressConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmssupiac.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties)
+ if err != nil {
+ return err
+ }
+ vmssupiac.VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties = &virtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties describes a virtual machines scale
+// set IP Configuration's PublicIPAddress configuration
+type VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties struct {
+ // IdleTimeoutInMinutes - The idle timeout of the public IP address.
+ IdleTimeoutInMinutes *int32 `json:"idleTimeoutInMinutes,omitempty"`
+ // DNSSettings - The dns settings to be applied on the publicIP addresses .
+ DNSSettings *VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings `json:"dnsSettings,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdateStorageProfile describes a virtual machine scale set storage profile.
+type VirtualMachineScaleSetUpdateStorageProfile struct {
+ // ImageReference - The image reference.
+ ImageReference *ImageReference `json:"imageReference,omitempty"`
+ // OsDisk - The OS disk.
+ OsDisk *VirtualMachineScaleSetUpdateOSDisk `json:"osDisk,omitempty"`
+ // DataDisks - The data disks.
+ DataDisks *[]VirtualMachineScaleSetDataDisk `json:"dataDisks,omitempty"`
+}
+
+// VirtualMachineScaleSetUpdateVMProfile describes a virtual machine scale set virtual machine profile.
+type VirtualMachineScaleSetUpdateVMProfile struct {
+ // OsProfile - The virtual machine scale set OS profile.
+ OsProfile *VirtualMachineScaleSetUpdateOSProfile `json:"osProfile,omitempty"`
+ // StorageProfile - The virtual machine scale set storage profile.
+ StorageProfile *VirtualMachineScaleSetUpdateStorageProfile `json:"storageProfile,omitempty"`
+ // NetworkProfile - The virtual machine scale set network profile.
+ NetworkProfile *VirtualMachineScaleSetUpdateNetworkProfile `json:"networkProfile,omitempty"`
+ // DiagnosticsProfile - The virtual machine scale set diagnostics profile.
+ DiagnosticsProfile *DiagnosticsProfile `json:"diagnosticsProfile,omitempty"`
+ // ExtensionProfile - The virtual machine scale set extension profile.
+ ExtensionProfile *VirtualMachineScaleSetExtensionProfile `json:"extensionProfile,omitempty"`
+ // LicenseType - The license type, which is for bring your own license scenario.
+ LicenseType *string `json:"licenseType,omitempty"`
+}
+
+// VirtualMachineScaleSetVM describes a virtual machine scale set virtual machine.
+type VirtualMachineScaleSetVM struct {
+ autorest.Response `json:"-"`
+ // InstanceID - READ-ONLY; The virtual machine instance ID.
+ InstanceID *string `json:"instanceId,omitempty"`
+ // Sku - READ-ONLY; The virtual machine SKU.
+ Sku *Sku `json:"sku,omitempty"`
+ *VirtualMachineScaleSetVMProperties `json:"properties,omitempty"`
+ // Plan - Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use. In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**.
+ Plan *Plan `json:"plan,omitempty"`
+ // Resources - READ-ONLY; The virtual machine child extension resources.
+ Resources *[]VirtualMachineExtension `json:"resources,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetVM.
+func (vmssv VirtualMachineScaleSetVM) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssv.VirtualMachineScaleSetVMProperties != nil {
+ objectMap["properties"] = vmssv.VirtualMachineScaleSetVMProperties
+ }
+ if vmssv.Plan != nil {
+ objectMap["plan"] = vmssv.Plan
+ }
+ if vmssv.Location != nil {
+ objectMap["location"] = vmssv.Location
+ }
+ if vmssv.Tags != nil {
+ objectMap["tags"] = vmssv.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineScaleSetVM struct.
+func (vmssv *VirtualMachineScaleSetVM) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "instanceId":
+ if v != nil {
+ var instanceID string
+ err = json.Unmarshal(*v, &instanceID)
+ if err != nil {
+ return err
+ }
+ vmssv.InstanceID = &instanceID
+ }
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ vmssv.Sku = &sku
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineScaleSetVMProperties VirtualMachineScaleSetVMProperties
+ err = json.Unmarshal(*v, &virtualMachineScaleSetVMProperties)
+ if err != nil {
+ return err
+ }
+ vmssv.VirtualMachineScaleSetVMProperties = &virtualMachineScaleSetVMProperties
+ }
+ case "plan":
+ if v != nil {
+ var plan Plan
+ err = json.Unmarshal(*v, &plan)
+ if err != nil {
+ return err
+ }
+ vmssv.Plan = &plan
+ }
+ case "resources":
+ if v != nil {
+ var resources []VirtualMachineExtension
+ err = json.Unmarshal(*v, &resources)
+ if err != nil {
+ return err
+ }
+ vmssv.Resources = &resources
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vmssv.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vmssv.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vmssv.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vmssv.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vmssv.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualMachineScaleSetVMExtensionsSummary extensions summary for virtual machines of a virtual machine
+// scale set.
+type VirtualMachineScaleSetVMExtensionsSummary struct {
+ // Name - READ-ONLY; The extension name.
+ Name *string `json:"name,omitempty"`
+ // StatusesSummary - READ-ONLY; The extensions information.
+ StatusesSummary *[]VirtualMachineStatusCodeCount `json:"statusesSummary,omitempty"`
+}
+
+// VirtualMachineScaleSetVMInstanceIDs specifies a list of virtual machine instance IDs from the VM scale
+// set.
+type VirtualMachineScaleSetVMInstanceIDs struct {
+ // InstanceIds - The virtual machine scale set instance ids. Omitting the virtual machine scale set instance ids will result in the operation being performed on all virtual machines in the virtual machine scale set.
+ InstanceIds *[]string `json:"instanceIds,omitempty"`
+}
+
+// VirtualMachineScaleSetVMInstanceRequiredIDs specifies a list of virtual machine instance IDs from the VM
+// scale set.
+type VirtualMachineScaleSetVMInstanceRequiredIDs struct {
+ // InstanceIds - The virtual machine scale set instance ids.
+ InstanceIds *[]string `json:"instanceIds,omitempty"`
+}
+
+// VirtualMachineScaleSetVMInstanceView the instance view of a virtual machine scale set VM.
+type VirtualMachineScaleSetVMInstanceView struct {
+ autorest.Response `json:"-"`
+ // PlatformUpdateDomain - The Update Domain count.
+ PlatformUpdateDomain *int32 `json:"platformUpdateDomain,omitempty"`
+ // PlatformFaultDomain - The Fault Domain count.
+ PlatformFaultDomain *int32 `json:"platformFaultDomain,omitempty"`
+ // RdpThumbPrint - The Remote desktop certificate thumbprint.
+ RdpThumbPrint *string `json:"rdpThumbPrint,omitempty"`
+ // VMAgent - The VM Agent running on the virtual machine.
+ VMAgent *VirtualMachineAgentInstanceView `json:"vmAgent,omitempty"`
+ // MaintenanceRedeployStatus - The Maintenance Operation status on the virtual machine.
+ MaintenanceRedeployStatus *MaintenanceRedeployStatus `json:"maintenanceRedeployStatus,omitempty"`
+ // Disks - The disks information.
+ Disks *[]DiskInstanceView `json:"disks,omitempty"`
+ // Extensions - The extensions information.
+ Extensions *[]VirtualMachineExtensionInstanceView `json:"extensions,omitempty"`
+ // VMHealth - READ-ONLY; The health status for the VM.
+ VMHealth *VirtualMachineHealthStatus `json:"vmHealth,omitempty"`
+ // BootDiagnostics - Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status.
You can easily view the output of your console log.
Azure also enables you to see a screenshot of the VM from the hypervisor.
+ BootDiagnostics *BootDiagnosticsInstanceView `json:"bootDiagnostics,omitempty"`
+ // Statuses - The resource status information.
+ Statuses *[]InstanceViewStatus `json:"statuses,omitempty"`
+ // PlacementGroupID - The placement group in which the VM is running. If the VM is deallocated it will not have a placementGroupId.
+ PlacementGroupID *string `json:"placementGroupId,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetVMInstanceView.
+func (vmssviv VirtualMachineScaleSetVMInstanceView) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssviv.PlatformUpdateDomain != nil {
+ objectMap["platformUpdateDomain"] = vmssviv.PlatformUpdateDomain
+ }
+ if vmssviv.PlatformFaultDomain != nil {
+ objectMap["platformFaultDomain"] = vmssviv.PlatformFaultDomain
+ }
+ if vmssviv.RdpThumbPrint != nil {
+ objectMap["rdpThumbPrint"] = vmssviv.RdpThumbPrint
+ }
+ if vmssviv.VMAgent != nil {
+ objectMap["vmAgent"] = vmssviv.VMAgent
+ }
+ if vmssviv.MaintenanceRedeployStatus != nil {
+ objectMap["maintenanceRedeployStatus"] = vmssviv.MaintenanceRedeployStatus
+ }
+ if vmssviv.Disks != nil {
+ objectMap["disks"] = vmssviv.Disks
+ }
+ if vmssviv.Extensions != nil {
+ objectMap["extensions"] = vmssviv.Extensions
+ }
+ if vmssviv.BootDiagnostics != nil {
+ objectMap["bootDiagnostics"] = vmssviv.BootDiagnostics
+ }
+ if vmssviv.Statuses != nil {
+ objectMap["statuses"] = vmssviv.Statuses
+ }
+ if vmssviv.PlacementGroupID != nil {
+ objectMap["placementGroupId"] = vmssviv.PlacementGroupID
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineScaleSetVMListResult the List Virtual Machine Scale Set VMs operation response.
+type VirtualMachineScaleSetVMListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of virtual machine scale sets VMs.
+ Value *[]VirtualMachineScaleSetVM `json:"value,omitempty"`
+ // NextLink - The uri to fetch the next page of Virtual Machine Scale Set VMs. Call ListNext() with this to fetch the next page of VMSS VMs
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualMachineScaleSetVMListResultIterator provides access to a complete listing of
+// VirtualMachineScaleSetVM values.
+type VirtualMachineScaleSetVMListResultIterator struct {
+ i int
+ page VirtualMachineScaleSetVMListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualMachineScaleSetVMListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualMachineScaleSetVMListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualMachineScaleSetVMListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualMachineScaleSetVMListResultIterator) Response() VirtualMachineScaleSetVMListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualMachineScaleSetVMListResultIterator) Value() VirtualMachineScaleSetVM {
+ if !iter.page.NotDone() {
+ return VirtualMachineScaleSetVM{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualMachineScaleSetVMListResultIterator type.
+func NewVirtualMachineScaleSetVMListResultIterator(page VirtualMachineScaleSetVMListResultPage) VirtualMachineScaleSetVMListResultIterator {
+ return VirtualMachineScaleSetVMListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vmssvlr VirtualMachineScaleSetVMListResult) IsEmpty() bool {
+ return vmssvlr.Value == nil || len(*vmssvlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vmssvlr VirtualMachineScaleSetVMListResult) hasNextLink() bool {
+ return vmssvlr.NextLink != nil && len(*vmssvlr.NextLink) != 0
+}
+
+// virtualMachineScaleSetVMListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vmssvlr VirtualMachineScaleSetVMListResult) virtualMachineScaleSetVMListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vmssvlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vmssvlr.NextLink)))
+}
+
+// VirtualMachineScaleSetVMListResultPage contains a page of VirtualMachineScaleSetVM values.
+type VirtualMachineScaleSetVMListResultPage struct {
+ fn func(context.Context, VirtualMachineScaleSetVMListResult) (VirtualMachineScaleSetVMListResult, error)
+ vmssvlr VirtualMachineScaleSetVMListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualMachineScaleSetVMListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vmssvlr)
+ if err != nil {
+ return err
+ }
+ page.vmssvlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualMachineScaleSetVMListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualMachineScaleSetVMListResultPage) NotDone() bool {
+ return !page.vmssvlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualMachineScaleSetVMListResultPage) Response() VirtualMachineScaleSetVMListResult {
+ return page.vmssvlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualMachineScaleSetVMListResultPage) Values() []VirtualMachineScaleSetVM {
+ if page.vmssvlr.IsEmpty() {
+ return nil
+ }
+ return *page.vmssvlr.Value
+}
+
+// Creates a new instance of the VirtualMachineScaleSetVMListResultPage type.
+func NewVirtualMachineScaleSetVMListResultPage(cur VirtualMachineScaleSetVMListResult, getNextPage func(context.Context, VirtualMachineScaleSetVMListResult) (VirtualMachineScaleSetVMListResult, error)) VirtualMachineScaleSetVMListResultPage {
+ return VirtualMachineScaleSetVMListResultPage{
+ fn: getNextPage,
+ vmssvlr: cur,
+ }
+}
+
+// VirtualMachineScaleSetVMProfile describes a virtual machine scale set virtual machine profile.
+type VirtualMachineScaleSetVMProfile struct {
+ // OsProfile - Specifies the operating system settings for the virtual machines in the scale set.
+ OsProfile *VirtualMachineScaleSetOSProfile `json:"osProfile,omitempty"`
+ // StorageProfile - Specifies the storage settings for the virtual machine disks.
+ StorageProfile *VirtualMachineScaleSetStorageProfile `json:"storageProfile,omitempty"`
+ // NetworkProfile - Specifies properties of the network interfaces of the virtual machines in the scale set.
+ NetworkProfile *VirtualMachineScaleSetNetworkProfile `json:"networkProfile,omitempty"`
+ // DiagnosticsProfile - Specifies the boot diagnostic settings state.
Minimum api-version: 2015-06-15.
+ DiagnosticsProfile *DiagnosticsProfile `json:"diagnosticsProfile,omitempty"`
+ // ExtensionProfile - Specifies a collection of settings for extensions installed on virtual machines in the scale set.
+ ExtensionProfile *VirtualMachineScaleSetExtensionProfile `json:"extensionProfile,omitempty"`
+ // LicenseType - Specifies that the image or disk that is being used was licensed on-premises. This element is only used for images that contain the Windows Server operating system.
Possible values are:
Windows_Client
Windows_Server
If this element is included in a request for an update, the value must match the initial value. This value cannot be updated.
For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-hybrid-use-benefit-licensing?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
Minimum api-version: 2015-06-15
+ LicenseType *string `json:"licenseType,omitempty"`
+ // Priority - Specifies the priority for the virtual machines in the scale set.
Minimum api-version: 2017-10-30-preview. Possible values include: 'Regular', 'Low'
+ Priority VirtualMachinePriorityTypes `json:"priority,omitempty"`
+ // EvictionPolicy - Specifies the eviction policy for virtual machines in a low priority scale set.
Minimum api-version: 2017-10-30-preview. Possible values include: 'Deallocate', 'Delete'
+ EvictionPolicy VirtualMachineEvictionPolicyTypes `json:"evictionPolicy,omitempty"`
+}
+
+// VirtualMachineScaleSetVMProperties describes the properties of a virtual machine scale set virtual
+// machine.
+type VirtualMachineScaleSetVMProperties struct {
+ // LatestModelApplied - READ-ONLY; Specifies whether the latest model has been applied to the virtual machine.
+ LatestModelApplied *bool `json:"latestModelApplied,omitempty"`
+ // VMID - READ-ONLY; Azure VM unique ID.
+ VMID *string `json:"vmId,omitempty"`
+ // InstanceView - READ-ONLY; The virtual machine instance view.
+ InstanceView *VirtualMachineScaleSetVMInstanceView `json:"instanceView,omitempty"`
+ // HardwareProfile - Specifies the hardware settings for the virtual machine.
+ HardwareProfile *HardwareProfile `json:"hardwareProfile,omitempty"`
+ // StorageProfile - Specifies the storage settings for the virtual machine disks.
+ StorageProfile *StorageProfile `json:"storageProfile,omitempty"`
+ // OsProfile - Specifies the operating system settings for the virtual machine.
+ OsProfile *OSProfile `json:"osProfile,omitempty"`
+ // NetworkProfile - Specifies the network interfaces of the virtual machine.
+ NetworkProfile *NetworkProfile `json:"networkProfile,omitempty"`
+ // DiagnosticsProfile - Specifies the boot diagnostic settings state.
Minimum api-version: 2015-06-15.
+ DiagnosticsProfile *DiagnosticsProfile `json:"diagnosticsProfile,omitempty"`
+ // AvailabilitySet - Specifies information about the availability set that the virtual machine should be assigned to. Virtual machines specified in the same availability set are allocated to different nodes to maximize availability. For more information about availability sets, see [Manage the availability of virtual machines](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-manage-availability?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json).
For more information on Azure planned maintenance, see [Planned maintenance for virtual machines in Azure](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-planned-maintenance?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
Currently, a VM can only be added to availability set at creation time. An existing VM cannot be added to an availability set.
+ AvailabilitySet *SubResource `json:"availabilitySet,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state, which only appears in the response.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // LicenseType - Specifies that the image or disk that is being used was licensed on-premises. This element is only used for images that contain the Windows Server operating system.
Possible values are:
Windows_Client
Windows_Server
If this element is included in a request for an update, the value must match the initial value. This value cannot be updated.
For more information, see [Azure Hybrid Use Benefit for Windows Server](https://docs.microsoft.com/azure/virtual-machines/virtual-machines-windows-hybrid-use-benefit-licensing?toc=%2fazure%2fvirtual-machines%2fwindows%2ftoc.json)
Minimum api-version: 2015-06-15
+ LicenseType *string `json:"licenseType,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineScaleSetVMProperties.
+func (vmssvp VirtualMachineScaleSetVMProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmssvp.HardwareProfile != nil {
+ objectMap["hardwareProfile"] = vmssvp.HardwareProfile
+ }
+ if vmssvp.StorageProfile != nil {
+ objectMap["storageProfile"] = vmssvp.StorageProfile
+ }
+ if vmssvp.OsProfile != nil {
+ objectMap["osProfile"] = vmssvp.OsProfile
+ }
+ if vmssvp.NetworkProfile != nil {
+ objectMap["networkProfile"] = vmssvp.NetworkProfile
+ }
+ if vmssvp.DiagnosticsProfile != nil {
+ objectMap["diagnosticsProfile"] = vmssvp.DiagnosticsProfile
+ }
+ if vmssvp.AvailabilitySet != nil {
+ objectMap["availabilitySet"] = vmssvp.AvailabilitySet
+ }
+ if vmssvp.LicenseType != nil {
+ objectMap["licenseType"] = vmssvp.LicenseType
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualMachineScaleSetVMsDeallocateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsDeallocateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsPerformMaintenanceFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualMachineScaleSetVMsPerformMaintenanceFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsPowerOffFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsPowerOffFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsRedeployFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsRedeployFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsReimageAllFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsReimageAllFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsReimageFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsReimageFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsRestartFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsRestartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsStartFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsStartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineScaleSetVMsUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachineScaleSetVMsUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachineScaleSetVMsClient) (VirtualMachineScaleSetVM, error)
+}
+
+// VirtualMachinesCaptureFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualMachinesCaptureFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (VirtualMachineCaptureResult, error)
+}
+
+// VirtualMachinesConvertToManagedDisksFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachinesConvertToManagedDisksFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachinesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachinesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (VirtualMachine, error)
+}
+
+// VirtualMachinesDeallocateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachinesDeallocateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachinesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualMachinesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineSize describes the properties of a VM size.
+type VirtualMachineSize struct {
+ // Name - The name of the virtual machine size.
+ Name *string `json:"name,omitempty"`
+ // NumberOfCores - The number of cores supported by the virtual machine size.
+ NumberOfCores *int32 `json:"numberOfCores,omitempty"`
+ // OsDiskSizeInMB - The OS disk size, in MB, allowed by the virtual machine size.
+ OsDiskSizeInMB *int32 `json:"osDiskSizeInMB,omitempty"`
+ // ResourceDiskSizeInMB - The resource disk size, in MB, allowed by the virtual machine size.
+ ResourceDiskSizeInMB *int32 `json:"resourceDiskSizeInMB,omitempty"`
+ // MemoryInMB - The amount of memory, in MB, supported by the virtual machine size.
+ MemoryInMB *int32 `json:"memoryInMB,omitempty"`
+ // MaxDataDiskCount - The maximum number of data disks that can be attached to the virtual machine size.
+ MaxDataDiskCount *int32 `json:"maxDataDiskCount,omitempty"`
+}
+
+// VirtualMachineSizeListResult the List Virtual Machine operation response.
+type VirtualMachineSizeListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of virtual machine sizes.
+ Value *[]VirtualMachineSize `json:"value,omitempty"`
+}
+
+// VirtualMachinesPerformMaintenanceFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachinesPerformMaintenanceFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachinesPowerOffFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualMachinesPowerOffFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachinesRedeployFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualMachinesRedeployFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachinesRestartFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualMachinesRestartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachinesRunCommandFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualMachinesRunCommandFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (RunCommandResult, error)
+}
+
+// VirtualMachinesStartFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualMachinesStartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (OperationStatusResponse, error)
+}
+
+// VirtualMachineStatusCodeCount the status code and count of the virtual machine scale set instance view
+// status summary.
+type VirtualMachineStatusCodeCount struct {
+ // Code - READ-ONLY; The instance view status code.
+ Code *string `json:"code,omitempty"`
+ // Count - READ-ONLY; The number of instances having a particular status code.
+ Count *int32 `json:"count,omitempty"`
+}
+
+// VirtualMachinesUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualMachinesUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualMachinesClient) (VirtualMachine, error)
+}
+
+// VirtualMachineUpdate describes a Virtual Machine Update.
+type VirtualMachineUpdate struct {
+ // Plan - Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use. In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**.
+ Plan *Plan `json:"plan,omitempty"`
+ *VirtualMachineProperties `json:"properties,omitempty"`
+ // Identity - The identity of the virtual machine, if configured.
+ Identity *VirtualMachineIdentity `json:"identity,omitempty"`
+ // Zones - The virtual machine zones.
+ Zones *[]string `json:"zones,omitempty"`
+ // Tags - Resource tags
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualMachineUpdate.
+func (vmu VirtualMachineUpdate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vmu.Plan != nil {
+ objectMap["plan"] = vmu.Plan
+ }
+ if vmu.VirtualMachineProperties != nil {
+ objectMap["properties"] = vmu.VirtualMachineProperties
+ }
+ if vmu.Identity != nil {
+ objectMap["identity"] = vmu.Identity
+ }
+ if vmu.Zones != nil {
+ objectMap["zones"] = vmu.Zones
+ }
+ if vmu.Tags != nil {
+ objectMap["tags"] = vmu.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualMachineUpdate struct.
+func (vmu *VirtualMachineUpdate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "plan":
+ if v != nil {
+ var plan Plan
+ err = json.Unmarshal(*v, &plan)
+ if err != nil {
+ return err
+ }
+ vmu.Plan = &plan
+ }
+ case "properties":
+ if v != nil {
+ var virtualMachineProperties VirtualMachineProperties
+ err = json.Unmarshal(*v, &virtualMachineProperties)
+ if err != nil {
+ return err
+ }
+ vmu.VirtualMachineProperties = &virtualMachineProperties
+ }
+ case "identity":
+ if v != nil {
+ var identity VirtualMachineIdentity
+ err = json.Unmarshal(*v, &identity)
+ if err != nil {
+ return err
+ }
+ vmu.Identity = &identity
+ }
+ case "zones":
+ if v != nil {
+ var zones []string
+ err = json.Unmarshal(*v, &zones)
+ if err != nil {
+ return err
+ }
+ vmu.Zones = &zones
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vmu.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// WindowsConfiguration specifies Windows operating system settings on the virtual machine.
+type WindowsConfiguration struct {
+ // ProvisionVMAgent - Indicates whether virtual machine agent should be provisioned on the virtual machine.
When this property is not specified in the request body, default behavior is to set it to true. This will ensure that VM Agent is installed on the VM so that extensions can be added to the VM later.
+ ProvisionVMAgent *bool `json:"provisionVMAgent,omitempty"`
+ // EnableAutomaticUpdates - Indicates whether virtual machine is enabled for automatic updates.
+ EnableAutomaticUpdates *bool `json:"enableAutomaticUpdates,omitempty"`
+ // TimeZone - Specifies the time zone of the virtual machine. e.g. "Pacific Standard Time"
+ TimeZone *string `json:"timeZone,omitempty"`
+ // AdditionalUnattendContent - Specifies additional base-64 encoded XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup.
+ AdditionalUnattendContent *[]AdditionalUnattendContent `json:"additionalUnattendContent,omitempty"`
+ // WinRM - Specifies the Windows Remote Management listeners. This enables remote Windows PowerShell.
+ WinRM *WinRMConfiguration `json:"winRM,omitempty"`
+}
+
+// WinRMConfiguration describes Windows Remote Management configuration of the VM
+type WinRMConfiguration struct {
+ // Listeners - The list of Windows Remote Management listeners
+ Listeners *[]WinRMListener `json:"listeners,omitempty"`
+}
+
+// WinRMListener describes Protocol and thumbprint of Windows Remote Management listener
+type WinRMListener struct {
+ // Protocol - Specifies the protocol of listener.
Possible values are:
**http**
**https**. Possible values include: 'HTTP', 'HTTPS'
+ Protocol ProtocolTypes `json:"protocol,omitempty"`
+ // CertificateURL - This is the URL of a certificate that has been uploaded to Key Vault as a secret. For adding a secret to the Key Vault, see [Add a key or secret to the key vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add). In this case, your certificate needs to be It is the Base64 encoding of the following JSON Object which is encoded in UTF-8:
{
"data":"",
"dataType":"pfx",
"password":""
}
+ CertificateURL *string `json:"certificateUrl,omitempty"`
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/operations.go
new file mode 100644
index 00000000000..077d3061609
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/operations.go
@@ -0,0 +1,109 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// OperationsClient is the compute Client
+type OperationsClient struct {
+ BaseClient
+}
+
+// NewOperationsClient creates an instance of the OperationsClient client.
+func NewOperationsClient(subscriptionID string) OperationsClient {
+ return NewOperationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewOperationsClientWithBaseURI creates an instance of the OperationsClient client using a custom endpoint. Use this
+// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+ return OperationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List gets a list of compute operations.
+func (client OperationsClient) List(ctx context.Context) (result OperationListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.OperationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.OperationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.OperationsClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Compute/operations"),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client OperationsClient) ListResponder(resp *http.Response) (result OperationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/resourceskus.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/resourceskus.go
new file mode 100644
index 00000000000..ba9243e02ad
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/resourceskus.go
@@ -0,0 +1,155 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ResourceSkusClient is the compute Client
+type ResourceSkusClient struct {
+ BaseClient
+}
+
+// NewResourceSkusClient creates an instance of the ResourceSkusClient client.
+func NewResourceSkusClient(subscriptionID string) ResourceSkusClient {
+ return NewResourceSkusClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewResourceSkusClientWithBaseURI creates an instance of the ResourceSkusClient client using a custom endpoint. Use
+// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewResourceSkusClientWithBaseURI(baseURI string, subscriptionID string) ResourceSkusClient {
+ return ResourceSkusClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List gets the list of Microsoft.Compute SKUs available for your Subscription.
+func (client ResourceSkusClient) List(ctx context.Context) (result ResourceSkusResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSkusClient.List")
+ defer func() {
+ sc := -1
+ if result.rsr.Response.Response != nil {
+ sc = result.rsr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ResourceSkusClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.rsr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.ResourceSkusClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.rsr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ResourceSkusClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.rsr.hasNextLink() && result.rsr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ResourceSkusClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/skus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ResourceSkusClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ResourceSkusClient) ListResponder(resp *http.Response) (result ResourceSkusResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ResourceSkusClient) listNextResults(ctx context.Context, lastResults ResourceSkusResult) (result ResourceSkusResult, err error) {
+ req, err := lastResults.resourceSkusResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.ResourceSkusClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.ResourceSkusClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.ResourceSkusClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ResourceSkusClient) ListComplete(ctx context.Context) (result ResourceSkusResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSkusClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/snapshots.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/snapshots.go
new file mode 100644
index 00000000000..3d8f73a3bb7
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/snapshots.go
@@ -0,0 +1,896 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// SnapshotsClient is the compute Client
+type SnapshotsClient struct {
+ BaseClient
+}
+
+// NewSnapshotsClient creates an instance of the SnapshotsClient client.
+func NewSnapshotsClient(subscriptionID string) SnapshotsClient {
+ return NewSnapshotsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewSnapshotsClientWithBaseURI creates an instance of the SnapshotsClient client using a custom endpoint. Use this
+// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewSnapshotsClientWithBaseURI(baseURI string, subscriptionID string) SnapshotsClient {
+ return SnapshotsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a snapshot.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// snapshotName - the name of the snapshot that is being created. The name can't be changed after the snapshot
+// is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The max name length is 80 characters.
+// snapshot - snapshot object supplied in the body of the Put disk operation.
+func (client SnapshotsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, snapshotName string, snapshot Snapshot) (result SnapshotsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: snapshot,
+ Constraints: []validation.Constraint{{Target: "snapshot.DiskProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "snapshot.DiskProperties.CreationData", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "snapshot.DiskProperties.CreationData.ImageReference", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "snapshot.DiskProperties.CreationData.ImageReference.ID", Name: validation.Null, Rule: true, Chain: nil}}},
+ }},
+ {Target: "snapshot.DiskProperties.EncryptionSettings", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "snapshot.DiskProperties.EncryptionSettings.DiskEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "snapshot.DiskProperties.EncryptionSettings.DiskEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "snapshot.DiskProperties.EncryptionSettings.DiskEncryptionKey.SecretURL", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "snapshot.DiskProperties.EncryptionSettings.KeyEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "snapshot.DiskProperties.EncryptionSettings.KeyEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "snapshot.DiskProperties.EncryptionSettings.KeyEncryptionKey.KeyURL", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("compute.SnapshotsClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, snapshotName, snapshot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client SnapshotsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, snapshotName string, snapshot Snapshot) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotName": autorest.Encode("path", snapshotName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ snapshot.ManagedBy = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/snapshots/{snapshotName}", pathParameters),
+ autorest.WithJSON(snapshot),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) CreateOrUpdateSender(req *http.Request) (future SnapshotsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SnapshotsClient) (s Snapshot, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.SnapshotsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ s.Response.Response, err = future.GetResult(sender)
+ if s.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && s.Response.Response.StatusCode != http.StatusNoContent {
+ s, err = client.CreateOrUpdateResponder(s.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsCreateOrUpdateFuture", "Result", s.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) CreateOrUpdateResponder(resp *http.Response) (result Snapshot, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes a snapshot.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// snapshotName - the name of the snapshot that is being created. The name can't be changed after the snapshot
+// is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The max name length is 80 characters.
+func (client SnapshotsClient) Delete(ctx context.Context, resourceGroupName string, snapshotName string) (result SnapshotsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, snapshotName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client SnapshotsClient) DeletePreparer(ctx context.Context, resourceGroupName string, snapshotName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotName": autorest.Encode("path", snapshotName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/snapshots/{snapshotName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) DeleteSender(req *http.Request) (future SnapshotsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SnapshotsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.SnapshotsDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get gets information about a snapshot.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// snapshotName - the name of the snapshot that is being created. The name can't be changed after the snapshot
+// is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The max name length is 80 characters.
+func (client SnapshotsClient) Get(ctx context.Context, resourceGroupName string, snapshotName string) (result Snapshot, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, snapshotName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client SnapshotsClient) GetPreparer(ctx context.Context, resourceGroupName string, snapshotName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotName": autorest.Encode("path", snapshotName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/snapshots/{snapshotName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) GetResponder(resp *http.Response) (result Snapshot, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GrantAccess grants access to a snapshot.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// snapshotName - the name of the snapshot that is being created. The name can't be changed after the snapshot
+// is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The max name length is 80 characters.
+// grantAccessData - access data object supplied in the body of the get snapshot access operation.
+func (client SnapshotsClient) GrantAccess(ctx context.Context, resourceGroupName string, snapshotName string, grantAccessData GrantAccessData) (result SnapshotsGrantAccessFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.GrantAccess")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: grantAccessData,
+ Constraints: []validation.Constraint{{Target: "grantAccessData.DurationInSeconds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.SnapshotsClient", "GrantAccess", err.Error())
+ }
+
+ req, err := client.GrantAccessPreparer(ctx, resourceGroupName, snapshotName, grantAccessData)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "GrantAccess", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GrantAccessSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "GrantAccess", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GrantAccessPreparer prepares the GrantAccess request.
+func (client SnapshotsClient) GrantAccessPreparer(ctx context.Context, resourceGroupName string, snapshotName string, grantAccessData GrantAccessData) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotName": autorest.Encode("path", snapshotName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/snapshots/{snapshotName}/beginGetAccess", pathParameters),
+ autorest.WithJSON(grantAccessData),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GrantAccessSender sends the GrantAccess request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) GrantAccessSender(req *http.Request) (future SnapshotsGrantAccessFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SnapshotsClient) (au AccessURI, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsGrantAccessFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.SnapshotsGrantAccessFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ au.Response.Response, err = future.GetResult(sender)
+ if au.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsGrantAccessFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && au.Response.Response.StatusCode != http.StatusNoContent {
+ au, err = client.GrantAccessResponder(au.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsGrantAccessFuture", "Result", au.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GrantAccessResponder handles the response to the GrantAccess request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) GrantAccessResponder(resp *http.Response) (result AccessURI, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists snapshots under a subscription.
+func (client SnapshotsClient) List(ctx context.Context) (result SnapshotListPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.List")
+ defer func() {
+ sc := -1
+ if result.sl.Response.Response != nil {
+ sc = result.sl.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.sl.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.sl, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.sl.hasNextLink() && result.sl.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client SnapshotsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/snapshots", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) ListResponder(resp *http.Response) (result SnapshotList, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client SnapshotsClient) listNextResults(ctx context.Context, lastResults SnapshotList) (result SnapshotList, err error) {
+ req, err := lastResults.snapshotListPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.SnapshotsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.SnapshotsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client SnapshotsClient) ListComplete(ctx context.Context) (result SnapshotListIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
+
+// ListByResourceGroup lists snapshots under a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client SnapshotsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result SnapshotListPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.sl.Response.Response != nil {
+ sc = result.sl.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listByResourceGroupNextResults
+ req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.sl.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result.sl, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "ListByResourceGroup", resp, "Failure responding to request")
+ return
+ }
+ if result.sl.hasNextLink() && result.sl.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client SnapshotsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/snapshots", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) ListByResourceGroupResponder(resp *http.Response) (result SnapshotList, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByResourceGroupNextResults retrieves the next set of results, if any.
+func (client SnapshotsClient) listByResourceGroupNextResults(ctx context.Context, lastResults SnapshotList) (result SnapshotList, err error) {
+ req, err := lastResults.snapshotListPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.SnapshotsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.SnapshotsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
+func (client SnapshotsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result SnapshotListIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
+ return
+}
+
+// RevokeAccess revokes access to a snapshot.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// snapshotName - the name of the snapshot that is being created. The name can't be changed after the snapshot
+// is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The max name length is 80 characters.
+func (client SnapshotsClient) RevokeAccess(ctx context.Context, resourceGroupName string, snapshotName string) (result SnapshotsRevokeAccessFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.RevokeAccess")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RevokeAccessPreparer(ctx, resourceGroupName, snapshotName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "RevokeAccess", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RevokeAccessSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "RevokeAccess", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RevokeAccessPreparer prepares the RevokeAccess request.
+func (client SnapshotsClient) RevokeAccessPreparer(ctx context.Context, resourceGroupName string, snapshotName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotName": autorest.Encode("path", snapshotName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/snapshots/{snapshotName}/endGetAccess", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RevokeAccessSender sends the RevokeAccess request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) RevokeAccessSender(req *http.Request) (future SnapshotsRevokeAccessFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SnapshotsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsRevokeAccessFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.SnapshotsRevokeAccessFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsRevokeAccessFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RevokeAccessResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsRevokeAccessFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RevokeAccessResponder handles the response to the RevokeAccess request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) RevokeAccessResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update updates (patches) a snapshot.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// snapshotName - the name of the snapshot that is being created. The name can't be changed after the snapshot
+// is created. Supported characters for the name are a-z, A-Z, 0-9 and _. The max name length is 80 characters.
+// snapshot - snapshot object supplied in the body of the Patch snapshot operation.
+func (client SnapshotsClient) Update(ctx context.Context, resourceGroupName string, snapshotName string, snapshot SnapshotUpdate) (result SnapshotsUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SnapshotsClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, snapshotName, snapshot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client SnapshotsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, snapshotName string, snapshot SnapshotUpdate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotName": autorest.Encode("path", snapshotName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/snapshots/{snapshotName}", pathParameters),
+ autorest.WithJSON(snapshot),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client SnapshotsClient) UpdateSender(req *http.Request) (future SnapshotsUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SnapshotsClient) (s Snapshot, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.SnapshotsUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ s.Response.Response, err = future.GetResult(sender)
+ if s.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && s.Response.Response.StatusCode != http.StatusNoContent {
+ s, err = client.UpdateResponder(s.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.SnapshotsUpdateFuture", "Result", s.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client SnapshotsClient) UpdateResponder(resp *http.Response) (result Snapshot, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/usage.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/usage.go
new file mode 100644
index 00000000000..84b2c0a44e9
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/usage.go
@@ -0,0 +1,166 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// UsageClient is the compute Client
+type UsageClient struct {
+ BaseClient
+}
+
+// NewUsageClient creates an instance of the UsageClient client.
+func NewUsageClient(subscriptionID string) UsageClient {
+ return NewUsageClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewUsageClientWithBaseURI creates an instance of the UsageClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewUsageClientWithBaseURI(baseURI string, subscriptionID string) UsageClient {
+ return UsageClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List gets, for the specified location, the current compute resource usage information as well as the limits for
+// compute resources under the subscription.
+// Parameters:
+// location - the location for which resource usage is queried.
+func (client UsageClient) List(ctx context.Context, location string) (result ListUsagesResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/UsageClient.List")
+ defer func() {
+ sc := -1
+ if result.lur.Response.Response != nil {
+ sc = result.lur.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.UsageClient", "List", err.Error())
+ }
+
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.UsageClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.lur.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.UsageClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.lur, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.UsageClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.lur.hasNextLink() && result.lur.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client UsageClient) ListPreparer(ctx context.Context, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client UsageClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client UsageClient) ListResponder(resp *http.Response) (result ListUsagesResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client UsageClient) listNextResults(ctx context.Context, lastResults ListUsagesResult) (result ListUsagesResult, err error) {
+ req, err := lastResults.listUsagesResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.UsageClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.UsageClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.UsageClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client UsageClient) ListComplete(ctx context.Context, location string) (result ListUsagesResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/UsageClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, location)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/version.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/version.go
new file mode 100644
index 00000000000..3dcd21f4edd
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/version.go
@@ -0,0 +1,30 @@
+package compute
+
+import "github.com/Azure/azure-sdk-for-go/version"
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// UserAgent returns the UserAgent string to use when sending http.Requests.
+func UserAgent() string {
+ return "Azure-SDK-For-Go/" + Version() + " compute/2017-12-01"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+ return version.Number
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineextensionimages.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineextensionimages.go
new file mode 100644
index 00000000000..1a72cb9e09e
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineextensionimages.go
@@ -0,0 +1,281 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineExtensionImagesClient is the compute Client
+type VirtualMachineExtensionImagesClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineExtensionImagesClient creates an instance of the VirtualMachineExtensionImagesClient client.
+func NewVirtualMachineExtensionImagesClient(subscriptionID string) VirtualMachineExtensionImagesClient {
+ return NewVirtualMachineExtensionImagesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineExtensionImagesClientWithBaseURI creates an instance of the VirtualMachineExtensionImagesClient
+// client using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI
+// (sovereign clouds, Azure stack).
+func NewVirtualMachineExtensionImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionImagesClient {
+ return VirtualMachineExtensionImagesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets a virtual machine extension image.
+// Parameters:
+// location - the name of a supported Azure region.
+func (client VirtualMachineExtensionImagesClient) Get(ctx context.Context, location string, publisherName string, typeParameter string, version string) (result VirtualMachineExtensionImage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionImagesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, location, publisherName, typeParameter, version)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachineExtensionImagesClient) GetPreparer(ctx context.Context, location string, publisherName string, typeParameter string, version string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "publisherName": autorest.Encode("path", publisherName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "type": autorest.Encode("path", typeParameter),
+ "version": autorest.Encode("path", version),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers/{publisherName}/artifacttypes/vmextension/types/{type}/versions/{version}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineExtensionImagesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineExtensionImagesClient) GetResponder(resp *http.Response) (result VirtualMachineExtensionImage, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListTypes gets a list of virtual machine extension image types.
+// Parameters:
+// location - the name of a supported Azure region.
+func (client VirtualMachineExtensionImagesClient) ListTypes(ctx context.Context, location string, publisherName string) (result ListVirtualMachineExtensionImage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionImagesClient.ListTypes")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListTypesPreparer(ctx, location, publisherName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "ListTypes", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListTypesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "ListTypes", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListTypesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "ListTypes", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListTypesPreparer prepares the ListTypes request.
+func (client VirtualMachineExtensionImagesClient) ListTypesPreparer(ctx context.Context, location string, publisherName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "publisherName": autorest.Encode("path", publisherName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers/{publisherName}/artifacttypes/vmextension/types", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListTypesSender sends the ListTypes request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineExtensionImagesClient) ListTypesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListTypesResponder handles the response to the ListTypes request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineExtensionImagesClient) ListTypesResponder(resp *http.Response) (result ListVirtualMachineExtensionImage, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListVersions gets a list of virtual machine extension image versions.
+// Parameters:
+// location - the name of a supported Azure region.
+// filter - the filter to apply on the operation.
+func (client VirtualMachineExtensionImagesClient) ListVersions(ctx context.Context, location string, publisherName string, typeParameter string, filter string, top *int32, orderby string) (result ListVirtualMachineExtensionImage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionImagesClient.ListVersions")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListVersionsPreparer(ctx, location, publisherName, typeParameter, filter, top, orderby)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "ListVersions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVersionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "ListVersions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListVersionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionImagesClient", "ListVersions", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListVersionsPreparer prepares the ListVersions request.
+func (client VirtualMachineExtensionImagesClient) ListVersionsPreparer(ctx context.Context, location string, publisherName string, typeParameter string, filter string, top *int32, orderby string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "publisherName": autorest.Encode("path", publisherName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "type": autorest.Encode("path", typeParameter),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = autorest.Encode("query", filter)
+ }
+ if top != nil {
+ queryParameters["$top"] = autorest.Encode("query", *top)
+ }
+ if len(orderby) > 0 {
+ queryParameters["$orderby"] = autorest.Encode("query", orderby)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers/{publisherName}/artifacttypes/vmextension/types/{type}/versions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListVersionsSender sends the ListVersions request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineExtensionImagesClient) ListVersionsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListVersionsResponder handles the response to the ListVersions request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineExtensionImagesClient) ListVersionsResponder(resp *http.Response) (result ListVirtualMachineExtensionImage, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineextensions.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineextensions.go
new file mode 100644
index 00000000000..c165480bab7
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineextensions.go
@@ -0,0 +1,440 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineExtensionsClient is the compute Client
+type VirtualMachineExtensionsClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineExtensionsClient creates an instance of the VirtualMachineExtensionsClient client.
+func NewVirtualMachineExtensionsClient(subscriptionID string) VirtualMachineExtensionsClient {
+ return NewVirtualMachineExtensionsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineExtensionsClientWithBaseURI creates an instance of the VirtualMachineExtensionsClient client using
+// a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
+// clouds, Azure stack).
+func NewVirtualMachineExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionsClient {
+ return VirtualMachineExtensionsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate the operation to create or update the extension.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine where the extension should be created or updated.
+// VMExtensionName - the name of the virtual machine extension.
+// extensionParameters - parameters supplied to the Create Virtual Machine Extension operation.
+func (client VirtualMachineExtensionsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtension) (result VirtualMachineExtensionsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, VMName, VMExtensionName, extensionParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualMachineExtensionsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtension) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmExtensionName": autorest.Encode("path", VMExtensionName),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
+ autorest.WithJSON(extensionParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineExtensionsClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachineExtensionsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineExtensionsClient) (vme VirtualMachineExtension, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineExtensionsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vme.Response.Response, err = future.GetResult(sender)
+ if vme.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vme.Response.Response.StatusCode != http.StatusNoContent {
+ vme, err = client.CreateOrUpdateResponder(vme.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsCreateOrUpdateFuture", "Result", vme.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineExtensionsClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualMachineExtension, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete the operation to delete the extension.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine where the extension should be deleted.
+// VMExtensionName - the name of the virtual machine extension.
+func (client VirtualMachineExtensionsClient) Delete(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string) (result VirtualMachineExtensionsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, VMName, VMExtensionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualMachineExtensionsClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmExtensionName": autorest.Encode("path", VMExtensionName),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineExtensionsClient) DeleteSender(req *http.Request) (future VirtualMachineExtensionsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineExtensionsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineExtensionsDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineExtensionsClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get the operation to get the extension.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine containing the extension.
+// VMExtensionName - the name of the virtual machine extension.
+// expand - the expand expression to apply on the operation.
+func (client VirtualMachineExtensionsClient) Get(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, expand string) (result VirtualMachineExtension, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, VMName, VMExtensionName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachineExtensionsClient) GetPreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmExtensionName": autorest.Encode("path", VMExtensionName),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineExtensionsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineExtensionsClient) GetResponder(resp *http.Response) (result VirtualMachineExtension, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update the operation to update the extension.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine where the extension should be updated.
+// VMExtensionName - the name of the virtual machine extension.
+// extensionParameters - parameters supplied to the Update Virtual Machine Extension operation.
+func (client VirtualMachineExtensionsClient) Update(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtensionUpdate) (result VirtualMachineExtensionsUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, VMName, VMExtensionName, extensionParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client VirtualMachineExtensionsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtensionUpdate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmExtensionName": autorest.Encode("path", VMExtensionName),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
+ autorest.WithJSON(extensionParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineExtensionsClient) UpdateSender(req *http.Request) (future VirtualMachineExtensionsUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineExtensionsClient) (vme VirtualMachineExtension, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineExtensionsUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vme.Response.Response, err = future.GetResult(sender)
+ if vme.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vme.Response.Response.StatusCode != http.StatusNoContent {
+ vme, err = client.UpdateResponder(vme.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsUpdateFuture", "Result", vme.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineExtensionsClient) UpdateResponder(resp *http.Response) (result VirtualMachineExtension, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineimages.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineimages.go
new file mode 100644
index 00000000000..73d3ff6df94
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineimages.go
@@ -0,0 +1,443 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineImagesClient is the compute Client
+type VirtualMachineImagesClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineImagesClient creates an instance of the VirtualMachineImagesClient client.
+func NewVirtualMachineImagesClient(subscriptionID string) VirtualMachineImagesClient {
+ return NewVirtualMachineImagesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineImagesClientWithBaseURI creates an instance of the VirtualMachineImagesClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewVirtualMachineImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineImagesClient {
+ return VirtualMachineImagesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets a virtual machine image.
+// Parameters:
+// location - the name of a supported Azure region.
+// publisherName - a valid image publisher.
+// offer - a valid image publisher offer.
+// skus - a valid image SKU.
+// version - a valid image SKU version.
+func (client VirtualMachineImagesClient) Get(ctx context.Context, location string, publisherName string, offer string, skus string, version string) (result VirtualMachineImage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineImagesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, location, publisherName, offer, skus, version)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachineImagesClient) GetPreparer(ctx context.Context, location string, publisherName string, offer string, skus string, version string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "offer": autorest.Encode("path", offer),
+ "publisherName": autorest.Encode("path", publisherName),
+ "skus": autorest.Encode("path", skus),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "version": autorest.Encode("path", version),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers/{publisherName}/artifacttypes/vmimage/offers/{offer}/skus/{skus}/versions/{version}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineImagesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineImagesClient) GetResponder(resp *http.Response) (result VirtualMachineImage, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets a list of all virtual machine image versions for the specified location, publisher, offer, and SKU.
+// Parameters:
+// location - the name of a supported Azure region.
+// publisherName - a valid image publisher.
+// offer - a valid image publisher offer.
+// skus - a valid image SKU.
+// expand - the expand expression to apply on the operation.
+func (client VirtualMachineImagesClient) List(ctx context.Context, location string, publisherName string, offer string, skus string, expand string, top *int32, orderby string) (result ListVirtualMachineImageResource, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineImagesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx, location, publisherName, offer, skus, expand, top, orderby)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualMachineImagesClient) ListPreparer(ctx context.Context, location string, publisherName string, offer string, skus string, expand string, top *int32, orderby string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "offer": autorest.Encode("path", offer),
+ "publisherName": autorest.Encode("path", publisherName),
+ "skus": autorest.Encode("path", skus),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+ if top != nil {
+ queryParameters["$top"] = autorest.Encode("query", *top)
+ }
+ if len(orderby) > 0 {
+ queryParameters["$orderby"] = autorest.Encode("query", orderby)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers/{publisherName}/artifacttypes/vmimage/offers/{offer}/skus/{skus}/versions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineImagesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineImagesClient) ListResponder(resp *http.Response) (result ListVirtualMachineImageResource, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListOffers gets a list of virtual machine image offers for the specified location and publisher.
+// Parameters:
+// location - the name of a supported Azure region.
+// publisherName - a valid image publisher.
+func (client VirtualMachineImagesClient) ListOffers(ctx context.Context, location string, publisherName string) (result ListVirtualMachineImageResource, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineImagesClient.ListOffers")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListOffersPreparer(ctx, location, publisherName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListOffers", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListOffersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListOffers", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListOffersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListOffers", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListOffersPreparer prepares the ListOffers request.
+func (client VirtualMachineImagesClient) ListOffersPreparer(ctx context.Context, location string, publisherName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "publisherName": autorest.Encode("path", publisherName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers/{publisherName}/artifacttypes/vmimage/offers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListOffersSender sends the ListOffers request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineImagesClient) ListOffersSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListOffersResponder handles the response to the ListOffers request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineImagesClient) ListOffersResponder(resp *http.Response) (result ListVirtualMachineImageResource, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPublishers gets a list of virtual machine image publishers for the specified Azure location.
+// Parameters:
+// location - the name of a supported Azure region.
+func (client VirtualMachineImagesClient) ListPublishers(ctx context.Context, location string) (result ListVirtualMachineImageResource, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineImagesClient.ListPublishers")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPublishersPreparer(ctx, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListPublishers", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPublishersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListPublishers", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPublishersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListPublishers", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPublishersPreparer prepares the ListPublishers request.
+func (client VirtualMachineImagesClient) ListPublishersPreparer(ctx context.Context, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListPublishersSender sends the ListPublishers request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineImagesClient) ListPublishersSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListPublishersResponder handles the response to the ListPublishers request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineImagesClient) ListPublishersResponder(resp *http.Response) (result ListVirtualMachineImageResource, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSkus gets a list of virtual machine image SKUs for the specified location, publisher, and offer.
+// Parameters:
+// location - the name of a supported Azure region.
+// publisherName - a valid image publisher.
+// offer - a valid image publisher offer.
+func (client VirtualMachineImagesClient) ListSkus(ctx context.Context, location string, publisherName string, offer string) (result ListVirtualMachineImageResource, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineImagesClient.ListSkus")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListSkusPreparer(ctx, location, publisherName, offer)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListSkus", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSkusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListSkus", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineImagesClient", "ListSkus", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListSkusPreparer prepares the ListSkus request.
+func (client VirtualMachineImagesClient) ListSkusPreparer(ctx context.Context, location string, publisherName string, offer string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "offer": autorest.Encode("path", offer),
+ "publisherName": autorest.Encode("path", publisherName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/publishers/{publisherName}/artifacttypes/vmimage/offers/{offer}/skus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSkusSender sends the ListSkus request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineImagesClient) ListSkusSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListSkusResponder handles the response to the ListSkus request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineImagesClient) ListSkusResponder(resp *http.Response) (result ListVirtualMachineImageResource, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineruncommands.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineruncommands.go
new file mode 100644
index 00000000000..d105ab45f94
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachineruncommands.go
@@ -0,0 +1,248 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineRunCommandsClient is the compute Client
+type VirtualMachineRunCommandsClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineRunCommandsClient creates an instance of the VirtualMachineRunCommandsClient client.
+func NewVirtualMachineRunCommandsClient(subscriptionID string) VirtualMachineRunCommandsClient {
+ return NewVirtualMachineRunCommandsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineRunCommandsClientWithBaseURI creates an instance of the VirtualMachineRunCommandsClient client
+// using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
+// clouds, Azure stack).
+func NewVirtualMachineRunCommandsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineRunCommandsClient {
+ return VirtualMachineRunCommandsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets specific run command for a subscription in a location.
+// Parameters:
+// location - the location upon which run commands is queried.
+// commandID - the command id.
+func (client VirtualMachineRunCommandsClient) Get(ctx context.Context, location string, commandID string) (result RunCommandDocument, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineRunCommandsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachineRunCommandsClient", "Get", err.Error())
+ }
+
+ req, err := client.GetPreparer(ctx, location, commandID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachineRunCommandsClient) GetPreparer(ctx context.Context, location string, commandID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "commandId": autorest.Encode("path", commandID),
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/runCommands/{commandId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineRunCommandsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineRunCommandsClient) GetResponder(resp *http.Response) (result RunCommandDocument, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all available run commands for a subscription in a location.
+// Parameters:
+// location - the location upon which run commands is queried.
+func (client VirtualMachineRunCommandsClient) List(ctx context.Context, location string) (result RunCommandListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineRunCommandsClient.List")
+ defer func() {
+ sc := -1
+ if result.rclr.Response.Response != nil {
+ sc = result.rclr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachineRunCommandsClient", "List", err.Error())
+ }
+
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.rclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.rclr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.rclr.hasNextLink() && result.rclr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualMachineRunCommandsClient) ListPreparer(ctx context.Context, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/runCommands", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineRunCommandsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineRunCommandsClient) ListResponder(resp *http.Response) (result RunCommandListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualMachineRunCommandsClient) listNextResults(ctx context.Context, lastResults RunCommandListResult) (result RunCommandListResult, err error) {
+ req, err := lastResults.runCommandListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineRunCommandsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachineRunCommandsClient) ListComplete(ctx context.Context, location string) (result RunCommandListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineRunCommandsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, location)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachines.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachines.go
new file mode 100644
index 00000000000..01e71ed6655
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachines.go
@@ -0,0 +1,2048 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachinesClient is the compute Client
+type VirtualMachinesClient struct {
+ BaseClient
+}
+
+// NewVirtualMachinesClient creates an instance of the VirtualMachinesClient client.
+func NewVirtualMachinesClient(subscriptionID string) VirtualMachinesClient {
+ return NewVirtualMachinesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachinesClientWithBaseURI creates an instance of the VirtualMachinesClient client using a custom endpoint.
+// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewVirtualMachinesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachinesClient {
+ return VirtualMachinesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Capture captures the VM by copying virtual hard disks of the VM and outputs a template that can be used to create
+// similar VMs.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+// parameters - parameters supplied to the Capture Virtual Machine operation.
+func (client VirtualMachinesClient) Capture(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachineCaptureParameters) (result VirtualMachinesCaptureFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Capture")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.VhdPrefix", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.DestinationContainerName", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.OverwriteVhds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachinesClient", "Capture", err.Error())
+ }
+
+ req, err := client.CapturePreparer(ctx, resourceGroupName, VMName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Capture", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CaptureSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Capture", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CapturePreparer prepares the Capture request.
+func (client VirtualMachinesClient) CapturePreparer(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachineCaptureParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/capture", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CaptureSender sends the Capture request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) CaptureSender(req *http.Request) (future VirtualMachinesCaptureFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (vmcr VirtualMachineCaptureResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesCaptureFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesCaptureFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vmcr.Response.Response, err = future.GetResult(sender)
+ if vmcr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesCaptureFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vmcr.Response.Response.StatusCode != http.StatusNoContent {
+ vmcr, err = client.CaptureResponder(vmcr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesCaptureFuture", "Result", vmcr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CaptureResponder handles the response to the Capture request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) CaptureResponder(resp *http.Response) (result VirtualMachineCaptureResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ConvertToManagedDisks converts virtual machine disks from blob-based to managed disks. Virtual machine must be
+// stop-deallocated before invoking this operation.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) ConvertToManagedDisks(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesConvertToManagedDisksFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ConvertToManagedDisks")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ConvertToManagedDisksPreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ConvertToManagedDisks", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ConvertToManagedDisksSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ConvertToManagedDisks", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ConvertToManagedDisksPreparer prepares the ConvertToManagedDisks request.
+func (client VirtualMachinesClient) ConvertToManagedDisksPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/convertToManagedDisks", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ConvertToManagedDisksSender sends the ConvertToManagedDisks request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) ConvertToManagedDisksSender(req *http.Request) (future VirtualMachinesConvertToManagedDisksFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesConvertToManagedDisksFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesConvertToManagedDisksFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesConvertToManagedDisksFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.ConvertToManagedDisksResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesConvertToManagedDisksFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ConvertToManagedDisksResponder handles the response to the ConvertToManagedDisks request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) ConvertToManagedDisksResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdate the operation to create or update a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+// parameters - parameters supplied to the Create Virtual Machine operation.
+func (client VirtualMachinesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachine) (result VirtualMachinesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.VirtualMachineProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey.SecretURL", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey.KeyURL", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachinesClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, VMName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualMachinesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachine) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ parameters.Resources = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachinesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (VM VirtualMachine, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ VM.Response.Response, err = future.GetResult(sender)
+ if VM.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && VM.Response.Response.StatusCode != http.StatusNoContent {
+ VM, err = client.CreateOrUpdateResponder(VM.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesCreateOrUpdateFuture", "Result", VM.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualMachine, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Deallocate shuts down the virtual machine and releases the compute resources. You are not billed for the compute
+// resources that this virtual machine uses.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) Deallocate(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesDeallocateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Deallocate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeallocatePreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Deallocate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeallocateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Deallocate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeallocatePreparer prepares the Deallocate request.
+func (client VirtualMachinesClient) DeallocatePreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/deallocate", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeallocateSender sends the Deallocate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) DeallocateSender(req *http.Request) (future VirtualMachinesDeallocateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesDeallocateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesDeallocateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesDeallocateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeallocateResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesDeallocateFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeallocateResponder handles the response to the Deallocate request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) DeallocateResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete the operation to delete a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) Delete(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualMachinesClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) DeleteSender(req *http.Request) (future VirtualMachinesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Generalize sets the state of the virtual machine to generalized.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) Generalize(ctx context.Context, resourceGroupName string, VMName string) (result OperationStatusResponse, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Generalize")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GeneralizePreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Generalize", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GeneralizeSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Generalize", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GeneralizeResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Generalize", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GeneralizePreparer prepares the Generalize request.
+func (client VirtualMachinesClient) GeneralizePreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/generalize", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GeneralizeSender sends the Generalize request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) GeneralizeSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GeneralizeResponder handles the response to the Generalize request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) GeneralizeResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get retrieves information about the model view or the instance view of a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+// expand - the expand expression to apply on the operation.
+func (client VirtualMachinesClient) Get(ctx context.Context, resourceGroupName string, VMName string, expand InstanceViewTypes) (result VirtualMachine, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, VMName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachinesClient) GetPreparer(ctx context.Context, resourceGroupName string, VMName string, expand InstanceViewTypes) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(string(expand)) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) GetResponder(resp *http.Response) (result VirtualMachine, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetExtensions the operation to get all extensions of a Virtual Machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine containing the extension.
+// expand - the expand expression to apply on the operation.
+func (client VirtualMachinesClient) GetExtensions(ctx context.Context, resourceGroupName string, VMName string, expand string) (result VirtualMachineExtensionsListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.GetExtensions")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetExtensionsPreparer(ctx, resourceGroupName, VMName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "GetExtensions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetExtensionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "GetExtensions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetExtensionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "GetExtensions", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetExtensionsPreparer prepares the GetExtensions request.
+func (client VirtualMachinesClient) GetExtensionsPreparer(ctx context.Context, resourceGroupName string, VMName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetExtensionsSender sends the GetExtensions request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) GetExtensionsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetExtensionsResponder handles the response to the GetExtensions request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) GetExtensionsResponder(resp *http.Response) (result VirtualMachineExtensionsListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// InstanceView retrieves information about the run-time state of a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) InstanceView(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachineInstanceView, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.InstanceView")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.InstanceViewPreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "InstanceView", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.InstanceViewSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "InstanceView", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.InstanceViewResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "InstanceView", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// InstanceViewPreparer prepares the InstanceView request.
+func (client VirtualMachinesClient) InstanceViewPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/instanceView", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// InstanceViewSender sends the InstanceView request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) InstanceViewSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// InstanceViewResponder handles the response to the InstanceView request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) InstanceViewResponder(resp *http.Response) (result VirtualMachineInstanceView, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all of the virtual machines in the specified resource group. Use the nextLink property in the response to
+// get the next page of virtual machines.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client VirtualMachinesClient) List(ctx context.Context, resourceGroupName string) (result VirtualMachineListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.List")
+ defer func() {
+ sc := -1
+ if result.vmlr.Response.Response != nil {
+ sc = result.vmlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vmlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vmlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vmlr.hasNextLink() && result.vmlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualMachinesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) ListResponder(resp *http.Response) (result VirtualMachineListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualMachinesClient) listNextResults(ctx context.Context, lastResults VirtualMachineListResult) (result VirtualMachineListResult, err error) {
+ req, err := lastResults.virtualMachineListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachinesClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualMachineListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll lists all of the virtual machines in the specified subscription. Use the nextLink property in the response
+// to get the next page of virtual machines.
+func (client VirtualMachinesClient) ListAll(ctx context.Context) (result VirtualMachineListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.vmlr.Response.Response != nil {
+ sc = result.vmlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.vmlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.vmlr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.vmlr.hasNextLink() && result.vmlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client VirtualMachinesClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachines", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) ListAllResponder(resp *http.Response) (result VirtualMachineListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client VirtualMachinesClient) listAllNextResults(ctx context.Context, lastResults VirtualMachineListResult) (result VirtualMachineListResult, err error) {
+ req, err := lastResults.virtualMachineListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachinesClient) ListAllComplete(ctx context.Context) (result VirtualMachineListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// ListAvailableSizes lists all available virtual machine sizes to which the specified virtual machine can be resized.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) ListAvailableSizes(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachineSizeListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListAvailableSizes")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListAvailableSizesPreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAvailableSizes", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAvailableSizesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAvailableSizes", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAvailableSizesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAvailableSizes", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListAvailableSizesPreparer prepares the ListAvailableSizes request.
+func (client VirtualMachinesClient) ListAvailableSizesPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/vmSizes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAvailableSizesSender sends the ListAvailableSizes request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) ListAvailableSizesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAvailableSizesResponder handles the response to the ListAvailableSizes request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) ListAvailableSizesResponder(resp *http.Response) (result VirtualMachineSizeListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByLocation gets all the virtual machines under the specified subscription for the specified location.
+// Parameters:
+// location - the location for which virtual machines under the subscription are queried.
+func (client VirtualMachinesClient) ListByLocation(ctx context.Context, location string) (result VirtualMachineListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListByLocation")
+ defer func() {
+ sc := -1
+ if result.vmlr.Response.Response != nil {
+ sc = result.vmlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachinesClient", "ListByLocation", err.Error())
+ }
+
+ result.fn = client.listByLocationNextResults
+ req, err := client.ListByLocationPreparer(ctx, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListByLocation", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByLocationSender(req)
+ if err != nil {
+ result.vmlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListByLocation", resp, "Failure sending request")
+ return
+ }
+
+ result.vmlr, err = client.ListByLocationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListByLocation", resp, "Failure responding to request")
+ return
+ }
+ if result.vmlr.hasNextLink() && result.vmlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListByLocationPreparer prepares the ListByLocation request.
+func (client VirtualMachinesClient) ListByLocationPreparer(ctx context.Context, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/virtualMachines", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByLocationSender sends the ListByLocation request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) ListByLocationSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByLocationResponder handles the response to the ListByLocation request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) ListByLocationResponder(resp *http.Response) (result VirtualMachineListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByLocationNextResults retrieves the next set of results, if any.
+func (client VirtualMachinesClient) listByLocationNextResults(ctx context.Context, lastResults VirtualMachineListResult) (result VirtualMachineListResult, err error) {
+ req, err := lastResults.virtualMachineListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listByLocationNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByLocationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listByLocationNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByLocationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listByLocationNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByLocationComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachinesClient) ListByLocationComplete(ctx context.Context, location string) (result VirtualMachineListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListByLocation")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListByLocation(ctx, location)
+ return
+}
+
+// PerformMaintenance the operation to perform maintenance on a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) PerformMaintenance(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesPerformMaintenanceFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.PerformMaintenance")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.PerformMaintenancePreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "PerformMaintenance", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.PerformMaintenanceSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "PerformMaintenance", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// PerformMaintenancePreparer prepares the PerformMaintenance request.
+func (client VirtualMachinesClient) PerformMaintenancePreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/performMaintenance", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// PerformMaintenanceSender sends the PerformMaintenance request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) PerformMaintenanceSender(req *http.Request) (future VirtualMachinesPerformMaintenanceFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesPerformMaintenanceFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesPerformMaintenanceFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesPerformMaintenanceFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.PerformMaintenanceResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesPerformMaintenanceFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// PerformMaintenanceResponder handles the response to the PerformMaintenance request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) PerformMaintenanceResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// PowerOff the operation to power off (stop) a virtual machine. The virtual machine can be restarted with the same
+// provisioned resources. You are still charged for this virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) PowerOff(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesPowerOffFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.PowerOff")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.PowerOffPreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "PowerOff", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.PowerOffSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "PowerOff", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// PowerOffPreparer prepares the PowerOff request.
+func (client VirtualMachinesClient) PowerOffPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/powerOff", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// PowerOffSender sends the PowerOff request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) PowerOffSender(req *http.Request) (future VirtualMachinesPowerOffFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesPowerOffFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesPowerOffFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesPowerOffFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.PowerOffResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesPowerOffFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// PowerOffResponder handles the response to the PowerOff request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) PowerOffResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Redeploy shuts down the virtual machine, moves it to a new node, and powers it back on.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) Redeploy(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesRedeployFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Redeploy")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RedeployPreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Redeploy", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RedeploySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Redeploy", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RedeployPreparer prepares the Redeploy request.
+func (client VirtualMachinesClient) RedeployPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/redeploy", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RedeploySender sends the Redeploy request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) RedeploySender(req *http.Request) (future VirtualMachinesRedeployFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRedeployFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesRedeployFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRedeployFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RedeployResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRedeployFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RedeployResponder handles the response to the Redeploy request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) RedeployResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Restart the operation to restart a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) Restart(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesRestartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Restart")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RestartPreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Restart", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RestartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Restart", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RestartPreparer prepares the Restart request.
+func (client VirtualMachinesClient) RestartPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RestartSender sends the Restart request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) RestartSender(req *http.Request) (future VirtualMachinesRestartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRestartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesRestartFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRestartFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RestartResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRestartFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RestartResponder handles the response to the Restart request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) RestartResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RunCommand run command on the VM.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+// parameters - parameters supplied to the Run command operation.
+func (client VirtualMachinesClient) RunCommand(ctx context.Context, resourceGroupName string, VMName string, parameters RunCommandInput) (result VirtualMachinesRunCommandFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.RunCommand")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.CommandID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachinesClient", "RunCommand", err.Error())
+ }
+
+ req, err := client.RunCommandPreparer(ctx, resourceGroupName, VMName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "RunCommand", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RunCommandSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "RunCommand", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RunCommandPreparer prepares the RunCommand request.
+func (client VirtualMachinesClient) RunCommandPreparer(ctx context.Context, resourceGroupName string, VMName string, parameters RunCommandInput) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/runCommand", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RunCommandSender sends the RunCommand request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) RunCommandSender(req *http.Request) (future VirtualMachinesRunCommandFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (rcr RunCommandResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRunCommandFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesRunCommandFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ rcr.Response.Response, err = future.GetResult(sender)
+ if rcr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRunCommandFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && rcr.Response.Response.StatusCode != http.StatusNoContent {
+ rcr, err = client.RunCommandResponder(rcr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesRunCommandFuture", "Result", rcr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RunCommandResponder handles the response to the RunCommand request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) RunCommandResponder(resp *http.Response) (result RunCommandResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Start the operation to start a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+func (client VirtualMachinesClient) Start(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesStartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Start")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StartPreparer(ctx, resourceGroupName, VMName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Start", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Start", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StartPreparer prepares the Start request.
+func (client VirtualMachinesClient) StartPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StartSender sends the Start request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) StartSender(req *http.Request) (future VirtualMachinesStartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesStartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesStartFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesStartFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.StartResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesStartFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// StartResponder handles the response to the Start request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) StartResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update the operation to update a virtual machine.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMName - the name of the virtual machine.
+// parameters - parameters supplied to the Update Virtual Machine operation.
+func (client VirtualMachinesClient) Update(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachineUpdate) (result VirtualMachinesUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, VMName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client VirtualMachinesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachineUpdate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmName": autorest.Encode("path", VMName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachinesClient) UpdateSender(req *http.Request) (future VirtualMachinesUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachinesClient) (VM VirtualMachine, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachinesUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ VM.Response.Response, err = future.GetResult(sender)
+ if VM.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && VM.Response.Response.StatusCode != http.StatusNoContent {
+ VM, err = client.UpdateResponder(VM.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachinesUpdateFuture", "Result", VM.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client VirtualMachinesClient) UpdateResponder(resp *http.Response) (result VirtualMachine, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetextensions.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetextensions.go
new file mode 100644
index 00000000000..09e927fce5f
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetextensions.go
@@ -0,0 +1,452 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineScaleSetExtensionsClient is the compute Client
+type VirtualMachineScaleSetExtensionsClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineScaleSetExtensionsClient creates an instance of the VirtualMachineScaleSetExtensionsClient client.
+func NewVirtualMachineScaleSetExtensionsClient(subscriptionID string) VirtualMachineScaleSetExtensionsClient {
+ return NewVirtualMachineScaleSetExtensionsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineScaleSetExtensionsClientWithBaseURI creates an instance of the
+// VirtualMachineScaleSetExtensionsClient client using a custom endpoint. Use this when interacting with an Azure
+// cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewVirtualMachineScaleSetExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetExtensionsClient {
+ return VirtualMachineScaleSetExtensionsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate the operation to create or update an extension.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set where the extension should be create or updated.
+// vmssExtensionName - the name of the VM scale set extension.
+// extensionParameters - parameters supplied to the Create VM scale set Extension operation.
+func (client VirtualMachineScaleSetExtensionsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string, extensionParameters VirtualMachineScaleSetExtension) (result VirtualMachineScaleSetExtensionsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetExtensionsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, VMScaleSetName, vmssExtensionName, extensionParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualMachineScaleSetExtensionsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string, extensionParameters VirtualMachineScaleSetExtension) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ "vmssExtensionName": autorest.Encode("path", vmssExtensionName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/extensions/{vmssExtensionName}", pathParameters),
+ autorest.WithJSON(extensionParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetExtensionsClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachineScaleSetExtensionsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetExtensionsClient) (vmsse VirtualMachineScaleSetExtension, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vmsse.Response.Response, err = future.GetResult(sender)
+ if vmsse.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vmsse.Response.Response.StatusCode != http.StatusNoContent {
+ vmsse, err = client.CreateOrUpdateResponder(vmsse.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture", "Result", vmsse.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetExtensionsClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualMachineScaleSetExtension, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete the operation to delete the extension.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set where the extension should be deleted.
+// vmssExtensionName - the name of the VM scale set extension.
+func (client VirtualMachineScaleSetExtensionsClient) Delete(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string) (result VirtualMachineScaleSetExtensionsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetExtensionsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, VMScaleSetName, vmssExtensionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualMachineScaleSetExtensionsClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ "vmssExtensionName": autorest.Encode("path", vmssExtensionName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/extensions/{vmssExtensionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetExtensionsClient) DeleteSender(req *http.Request) (future VirtualMachineScaleSetExtensionsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetExtensionsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetExtensionsDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetExtensionsClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get the operation to get the extension.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set containing the extension.
+// vmssExtensionName - the name of the VM scale set extension.
+// expand - the expand expression to apply on the operation.
+func (client VirtualMachineScaleSetExtensionsClient) Get(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string, expand string) (result VirtualMachineScaleSetExtension, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetExtensionsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, VMScaleSetName, vmssExtensionName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachineScaleSetExtensionsClient) GetPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ "vmssExtensionName": autorest.Encode("path", vmssExtensionName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/extensions/{vmssExtensionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetExtensionsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetExtensionsClient) GetResponder(resp *http.Response) (result VirtualMachineScaleSetExtension, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets a list of all extensions in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set containing the extension.
+func (client VirtualMachineScaleSetExtensionsClient) List(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetExtensionListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetExtensionsClient.List")
+ defer func() {
+ sc := -1
+ if result.vmsselr.Response.Response != nil {
+ sc = result.vmsselr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vmsselr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vmsselr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vmsselr.hasNextLink() && result.vmsselr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualMachineScaleSetExtensionsClient) ListPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/extensions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetExtensionsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetExtensionsClient) ListResponder(resp *http.Response) (result VirtualMachineScaleSetExtensionListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualMachineScaleSetExtensionsClient) listNextResults(ctx context.Context, lastResults VirtualMachineScaleSetExtensionListResult) (result VirtualMachineScaleSetExtensionListResult, err error) {
+ req, err := lastResults.virtualMachineScaleSetExtensionListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetExtensionsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachineScaleSetExtensionsClient) ListComplete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetExtensionListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetExtensionsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, VMScaleSetName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetrollingupgrades.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetrollingupgrades.go
new file mode 100644
index 00000000000..3d47a92a38f
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetrollingupgrades.go
@@ -0,0 +1,323 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineScaleSetRollingUpgradesClient is the compute Client
+type VirtualMachineScaleSetRollingUpgradesClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineScaleSetRollingUpgradesClient creates an instance of the
+// VirtualMachineScaleSetRollingUpgradesClient client.
+func NewVirtualMachineScaleSetRollingUpgradesClient(subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
+ return NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI creates an instance of the
+// VirtualMachineScaleSetRollingUpgradesClient client using a custom endpoint. Use this when interacting with an Azure
+// cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
+ return VirtualMachineScaleSetRollingUpgradesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Cancel cancels the current virtual machine scale set rolling upgrade.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetRollingUpgradesClient) Cancel(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetRollingUpgradesCancelFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetRollingUpgradesClient.Cancel")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CancelPreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesClient", "Cancel", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CancelSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesClient", "Cancel", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CancelPreparer prepares the Cancel request.
+func (client VirtualMachineScaleSetRollingUpgradesClient) CancelPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/rollingUpgrades/cancel", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CancelSender sends the Cancel request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetRollingUpgradesClient) CancelSender(req *http.Request) (future VirtualMachineScaleSetRollingUpgradesCancelFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetRollingUpgradesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesCancelFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetRollingUpgradesCancelFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesCancelFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.CancelResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesCancelFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CancelResponder handles the response to the Cancel request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetRollingUpgradesClient) CancelResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetLatest gets the status of the latest virtual machine scale set rolling upgrade.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetRollingUpgradesClient) GetLatest(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result RollingUpgradeStatusInfo, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetRollingUpgradesClient.GetLatest")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetLatestPreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesClient", "GetLatest", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetLatestSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesClient", "GetLatest", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetLatestResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesClient", "GetLatest", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetLatestPreparer prepares the GetLatest request.
+func (client VirtualMachineScaleSetRollingUpgradesClient) GetLatestPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/rollingUpgrades/latest", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetLatestSender sends the GetLatest request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetRollingUpgradesClient) GetLatestSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetLatestResponder handles the response to the GetLatest request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetRollingUpgradesClient) GetLatestResponder(resp *http.Response) (result RollingUpgradeStatusInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// StartOSUpgrade starts a rolling upgrade to move all virtual machine scale set instances to the latest available
+// Platform Image OS version. Instances which are already running the latest available OS version are not affected.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetRollingUpgradesClient) StartOSUpgrade(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetRollingUpgradesClient.StartOSUpgrade")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StartOSUpgradePreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesClient", "StartOSUpgrade", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StartOSUpgradeSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesClient", "StartOSUpgrade", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StartOSUpgradePreparer prepares the StartOSUpgrade request.
+func (client VirtualMachineScaleSetRollingUpgradesClient) StartOSUpgradePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/osRollingUpgrade", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StartOSUpgradeSender sends the StartOSUpgrade request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetRollingUpgradesClient) StartOSUpgradeSender(req *http.Request) (future VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetRollingUpgradesClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.StartOSUpgradeResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// StartOSUpgradeResponder handles the response to the StartOSUpgrade request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetRollingUpgradesClient) StartOSUpgradeResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesets.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesets.go
new file mode 100644
index 00000000000..72d2eb967ab
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesets.go
@@ -0,0 +1,2157 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineScaleSetsClient is the compute Client
+type VirtualMachineScaleSetsClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineScaleSetsClient creates an instance of the VirtualMachineScaleSetsClient client.
+func NewVirtualMachineScaleSetsClient(subscriptionID string) VirtualMachineScaleSetsClient {
+ return NewVirtualMachineScaleSetsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineScaleSetsClientWithBaseURI creates an instance of the VirtualMachineScaleSetsClient client using a
+// custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds,
+// Azure stack).
+func NewVirtualMachineScaleSetsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetsClient {
+ return VirtualMachineScaleSetsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or update a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set to create or update.
+// parameters - the scale set object.
+func (client VirtualMachineScaleSetsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSet) (result VirtualMachineScaleSetsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxBatchInstancePercent", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxBatchInstancePercent", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
+ {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxBatchInstancePercent", Name: validation.InclusiveMinimum, Rule: int64(5), Chain: nil},
+ }},
+ {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyInstancePercent", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyInstancePercent", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
+ {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyInstancePercent", Name: validation.InclusiveMinimum, Rule: int64(5), Chain: nil},
+ }},
+ {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyUpgradedInstancePercent", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyUpgradedInstancePercent", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
+ {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyUpgradedInstancePercent", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil},
+ }},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachineScaleSetsClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, VMScaleSetName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualMachineScaleSetsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSet) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachineScaleSetsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (vmss VirtualMachineScaleSet, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vmss.Response.Response, err = future.GetResult(sender)
+ if vmss.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vmss.Response.Response.StatusCode != http.StatusNoContent {
+ vmss, err = client.CreateOrUpdateResponder(vmss.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsCreateOrUpdateFuture", "Result", vmss.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualMachineScaleSet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Deallocate deallocates specific virtual machines in a VM scale set. Shuts down the virtual machines and releases the
+// compute resources. You are not billed for the compute resources that this virtual machine scale set deallocates.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) Deallocate(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsDeallocateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Deallocate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeallocatePreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Deallocate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeallocateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Deallocate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeallocatePreparer prepares the Deallocate request.
+func (client VirtualMachineScaleSetsClient) DeallocatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/deallocate", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeallocateSender sends the Deallocate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) DeallocateSender(req *http.Request) (future VirtualMachineScaleSetsDeallocateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeallocateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsDeallocateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeallocateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeallocateResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeallocateFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeallocateResponder handles the response to the Deallocate request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) DeallocateResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetsClient) Delete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualMachineScaleSetsClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) DeleteSender(req *http.Request) (future VirtualMachineScaleSetsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// DeleteInstances deletes virtual machines in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) DeleteInstances(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (result VirtualMachineScaleSetsDeleteInstancesFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.DeleteInstances")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: VMInstanceIDs,
+ Constraints: []validation.Constraint{{Target: "VMInstanceIDs.InstanceIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachineScaleSetsClient", "DeleteInstances", err.Error())
+ }
+
+ req, err := client.DeleteInstancesPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "DeleteInstances", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteInstancesSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "DeleteInstances", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeleteInstancesPreparer prepares the DeleteInstances request.
+func (client VirtualMachineScaleSetsClient) DeleteInstancesPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/delete", pathParameters),
+ autorest.WithJSON(VMInstanceIDs),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteInstancesSender sends the DeleteInstances request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) DeleteInstancesSender(req *http.Request) (future VirtualMachineScaleSetsDeleteInstancesFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeleteInstancesFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsDeleteInstancesFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeleteInstancesFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteInstancesResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsDeleteInstancesFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteInstancesResponder handles the response to the DeleteInstances request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) DeleteInstancesResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ForceRecoveryServiceFabricPlatformUpdateDomainWalk manual platform update domain walk to update virtual machines in
+// a service fabric virtual machine scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// platformUpdateDomain - the platform update domain for which a manual recovery walk is requested
+func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalk(ctx context.Context, resourceGroupName string, VMScaleSetName string, platformUpdateDomain int32) (result RecoveryWalkResponse, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ForceRecoveryServiceFabricPlatformUpdateDomainWalk")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ForceRecoveryServiceFabricPlatformUpdateDomainWalkPreparer(ctx, resourceGroupName, VMScaleSetName, platformUpdateDomain)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ForceRecoveryServiceFabricPlatformUpdateDomainWalk", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ForceRecoveryServiceFabricPlatformUpdateDomainWalkSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ForceRecoveryServiceFabricPlatformUpdateDomainWalk", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ForceRecoveryServiceFabricPlatformUpdateDomainWalkResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ForceRecoveryServiceFabricPlatformUpdateDomainWalk", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ForceRecoveryServiceFabricPlatformUpdateDomainWalkPreparer prepares the ForceRecoveryServiceFabricPlatformUpdateDomainWalk request.
+func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalkPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, platformUpdateDomain int32) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ "platformUpdateDomain": autorest.Encode("query", platformUpdateDomain),
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/forceRecoveryServiceFabricPlatformUpdateDomainWalk", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ForceRecoveryServiceFabricPlatformUpdateDomainWalkSender sends the ForceRecoveryServiceFabricPlatformUpdateDomainWalk request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalkSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ForceRecoveryServiceFabricPlatformUpdateDomainWalkResponder handles the response to the ForceRecoveryServiceFabricPlatformUpdateDomainWalk request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalkResponder(resp *http.Response) (result RecoveryWalkResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get display information about a virtual machine scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetsClient) Get(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSet, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachineScaleSetsClient) GetPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) GetResponder(resp *http.Response) (result VirtualMachineScaleSet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetInstanceView gets the status of a VM scale set instance.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetsClient) GetInstanceView(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetInstanceView, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.GetInstanceView")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetInstanceViewPreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetInstanceView", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetInstanceViewSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetInstanceView", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetInstanceViewResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetInstanceView", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetInstanceViewPreparer prepares the GetInstanceView request.
+func (client VirtualMachineScaleSetsClient) GetInstanceViewPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/instanceView", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetInstanceViewSender sends the GetInstanceView request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) GetInstanceViewSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetInstanceViewResponder handles the response to the GetInstanceView request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) GetInstanceViewResponder(resp *http.Response) (result VirtualMachineScaleSetInstanceView, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetOSUpgradeHistory gets list of OS upgrades on a VM scale set instance.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistory(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListOSUpgradeHistoryPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.GetOSUpgradeHistory")
+ defer func() {
+ sc := -1
+ if result.vmsslouh.Response.Response != nil {
+ sc = result.vmsslouh.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.getOSUpgradeHistoryNextResults
+ req, err := client.GetOSUpgradeHistoryPreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetOSUpgradeHistory", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetOSUpgradeHistorySender(req)
+ if err != nil {
+ result.vmsslouh.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetOSUpgradeHistory", resp, "Failure sending request")
+ return
+ }
+
+ result.vmsslouh, err = client.GetOSUpgradeHistoryResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetOSUpgradeHistory", resp, "Failure responding to request")
+ return
+ }
+ if result.vmsslouh.hasNextLink() && result.vmsslouh.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// GetOSUpgradeHistoryPreparer prepares the GetOSUpgradeHistory request.
+func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistoryPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/osUpgradeHistory", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetOSUpgradeHistorySender sends the GetOSUpgradeHistory request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistorySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetOSUpgradeHistoryResponder handles the response to the GetOSUpgradeHistory request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistoryResponder(resp *http.Response) (result VirtualMachineScaleSetListOSUpgradeHistory, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// getOSUpgradeHistoryNextResults retrieves the next set of results, if any.
+func (client VirtualMachineScaleSetsClient) getOSUpgradeHistoryNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListOSUpgradeHistory) (result VirtualMachineScaleSetListOSUpgradeHistory, err error) {
+ req, err := lastResults.virtualMachineScaleSetListOSUpgradeHistoryPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "getOSUpgradeHistoryNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.GetOSUpgradeHistorySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "getOSUpgradeHistoryNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.GetOSUpgradeHistoryResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "getOSUpgradeHistoryNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// GetOSUpgradeHistoryComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistoryComplete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListOSUpgradeHistoryIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.GetOSUpgradeHistory")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.GetOSUpgradeHistory(ctx, resourceGroupName, VMScaleSetName)
+ return
+}
+
+// List gets a list of all VM scale sets under a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client VirtualMachineScaleSetsClient) List(ctx context.Context, resourceGroupName string) (result VirtualMachineScaleSetListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.List")
+ defer func() {
+ sc := -1
+ if result.vmsslr.Response.Response != nil {
+ sc = result.vmsslr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vmsslr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vmsslr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vmsslr.hasNextLink() && result.vmsslr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualMachineScaleSetsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) ListResponder(resp *http.Response) (result VirtualMachineScaleSetListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualMachineScaleSetsClient) listNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListResult) (result VirtualMachineScaleSetListResult, err error) {
+ req, err := lastResults.virtualMachineScaleSetListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachineScaleSetsClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualMachineScaleSetListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets a list of all VM Scale Sets in the subscription, regardless of the associated resource group. Use
+// nextLink property in the response to get the next page of VM Scale Sets. Do this till nextLink is null to fetch all
+// the VM Scale Sets.
+func (client VirtualMachineScaleSetsClient) ListAll(ctx context.Context) (result VirtualMachineScaleSetListWithLinkResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.vmsslwlr.Response.Response != nil {
+ sc = result.vmsslwlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.vmsslwlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.vmsslwlr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.vmsslwlr.hasNextLink() && result.vmsslwlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client VirtualMachineScaleSetsClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachineScaleSets", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) ListAllResponder(resp *http.Response) (result VirtualMachineScaleSetListWithLinkResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client VirtualMachineScaleSetsClient) listAllNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListWithLinkResult) (result VirtualMachineScaleSetListWithLinkResult, err error) {
+ req, err := lastResults.virtualMachineScaleSetListWithLinkResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachineScaleSetsClient) ListAllComplete(ctx context.Context) (result VirtualMachineScaleSetListWithLinkResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// ListSkus gets a list of SKUs available for your VM scale set, including the minimum and maximum VM instances allowed
+// for each SKU.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+func (client VirtualMachineScaleSetsClient) ListSkus(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListSkusResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListSkus")
+ defer func() {
+ sc := -1
+ if result.vmsslsr.Response.Response != nil {
+ sc = result.vmsslsr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listSkusNextResults
+ req, err := client.ListSkusPreparer(ctx, resourceGroupName, VMScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListSkus", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSkusSender(req)
+ if err != nil {
+ result.vmsslsr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListSkus", resp, "Failure sending request")
+ return
+ }
+
+ result.vmsslsr, err = client.ListSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListSkus", resp, "Failure responding to request")
+ return
+ }
+ if result.vmsslsr.hasNextLink() && result.vmsslsr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListSkusPreparer prepares the ListSkus request.
+func (client VirtualMachineScaleSetsClient) ListSkusPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/skus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSkusSender sends the ListSkus request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) ListSkusSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListSkusResponder handles the response to the ListSkus request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) ListSkusResponder(resp *http.Response) (result VirtualMachineScaleSetListSkusResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listSkusNextResults retrieves the next set of results, if any.
+func (client VirtualMachineScaleSetsClient) listSkusNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListSkusResult) (result VirtualMachineScaleSetListSkusResult, err error) {
+ req, err := lastResults.virtualMachineScaleSetListSkusResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listSkusNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSkusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listSkusNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listSkusNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListSkusComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachineScaleSetsClient) ListSkusComplete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListSkusResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListSkus")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListSkus(ctx, resourceGroupName, VMScaleSetName)
+ return
+}
+
+// PerformMaintenance perform maintenance on one or more virtual machines in a VM scale set. Operation on instances
+// which are not eligible for perform maintenance will be failed. Please refer to best practices for more details:
+// https://docs.microsoft.com/en-us/azure/virtual-machine-scale-sets/virtual-machine-scale-sets-maintenance-notifications
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) PerformMaintenance(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsPerformMaintenanceFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.PerformMaintenance")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.PerformMaintenancePreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PerformMaintenance", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.PerformMaintenanceSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PerformMaintenance", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// PerformMaintenancePreparer prepares the PerformMaintenance request.
+func (client VirtualMachineScaleSetsClient) PerformMaintenancePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/performMaintenance", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// PerformMaintenanceSender sends the PerformMaintenance request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) PerformMaintenanceSender(req *http.Request) (future VirtualMachineScaleSetsPerformMaintenanceFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsPerformMaintenanceFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsPerformMaintenanceFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsPerformMaintenanceFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.PerformMaintenanceResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsPerformMaintenanceFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// PerformMaintenanceResponder handles the response to the PerformMaintenance request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) PerformMaintenanceResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// PowerOff power off (stop) one or more virtual machines in a VM scale set. Note that resources are still attached and
+// you are getting charged for the resources. Instead, use deallocate to release resources and avoid charges.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) PowerOff(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsPowerOffFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.PowerOff")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.PowerOffPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PowerOff", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.PowerOffSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PowerOff", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// PowerOffPreparer prepares the PowerOff request.
+func (client VirtualMachineScaleSetsClient) PowerOffPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/poweroff", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// PowerOffSender sends the PowerOff request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) PowerOffSender(req *http.Request) (future VirtualMachineScaleSetsPowerOffFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsPowerOffFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsPowerOffFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsPowerOffFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.PowerOffResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsPowerOffFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// PowerOffResponder handles the response to the PowerOff request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) PowerOffResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Redeploy shuts down all the virtual machines in the virtual machine scale set, moves them to a new node, and powers
+// them back on.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) Redeploy(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsRedeployFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Redeploy")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RedeployPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Redeploy", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RedeploySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Redeploy", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RedeployPreparer prepares the Redeploy request.
+func (client VirtualMachineScaleSetsClient) RedeployPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/redeploy", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RedeploySender sends the Redeploy request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) RedeploySender(req *http.Request) (future VirtualMachineScaleSetsRedeployFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsRedeployFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsRedeployFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsRedeployFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RedeployResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsRedeployFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RedeployResponder handles the response to the Redeploy request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) RedeployResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Reimage reimages (upgrade the operating system) one or more virtual machines in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) Reimage(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsReimageFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Reimage")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ReimagePreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Reimage", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ReimageSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Reimage", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ReimagePreparer prepares the Reimage request.
+func (client VirtualMachineScaleSetsClient) ReimagePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimage", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ReimageSender sends the Reimage request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) ReimageSender(req *http.Request) (future VirtualMachineScaleSetsReimageFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsReimageFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsReimageFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsReimageFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.ReimageResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsReimageFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ReimageResponder handles the response to the Reimage request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) ReimageResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ReimageAll reimages all the disks ( including data disks ) in the virtual machines in a VM scale set. This operation
+// is only supported for managed disks.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) ReimageAll(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsReimageAllFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ReimageAll")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ReimageAllPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ReimageAll", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ReimageAllSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ReimageAll", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ReimageAllPreparer prepares the ReimageAll request.
+func (client VirtualMachineScaleSetsClient) ReimageAllPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimageall", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ReimageAllSender sends the ReimageAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) ReimageAllSender(req *http.Request) (future VirtualMachineScaleSetsReimageAllFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsReimageAllFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsReimageAllFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsReimageAllFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.ReimageAllResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsReimageAllFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ReimageAllResponder handles the response to the ReimageAll request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) ReimageAllResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Restart restarts one or more virtual machines in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) Restart(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsRestartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Restart")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RestartPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Restart", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RestartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Restart", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RestartPreparer prepares the Restart request.
+func (client VirtualMachineScaleSetsClient) RestartPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/restart", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RestartSender sends the Restart request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) RestartSender(req *http.Request) (future VirtualMachineScaleSetsRestartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsRestartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsRestartFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsRestartFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RestartResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsRestartFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RestartResponder handles the response to the Restart request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) RestartResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Start starts one or more virtual machines in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) Start(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsStartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Start")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StartPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Start", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Start", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StartPreparer prepares the Start request.
+func (client VirtualMachineScaleSetsClient) StartPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ if VMInstanceIDs != nil {
+ preparer = autorest.DecoratePreparer(preparer,
+ autorest.WithJSON(VMInstanceIDs))
+ }
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StartSender sends the Start request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) StartSender(req *http.Request) (future VirtualMachineScaleSetsStartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsStartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsStartFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsStartFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.StartResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsStartFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// StartResponder handles the response to the Start request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) StartResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update update a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set to create or update.
+// parameters - the scale set object.
+func (client VirtualMachineScaleSetsClient) Update(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSetUpdate) (result VirtualMachineScaleSetsUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, VMScaleSetName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client VirtualMachineScaleSetsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSetUpdate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) UpdateSender(req *http.Request) (future VirtualMachineScaleSetsUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (vmss VirtualMachineScaleSet, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vmss.Response.Response, err = future.GetResult(sender)
+ if vmss.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vmss.Response.Response.StatusCode != http.StatusNoContent {
+ vmss, err = client.UpdateResponder(vmss.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsUpdateFuture", "Result", vmss.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) UpdateResponder(resp *http.Response) (result VirtualMachineScaleSet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateInstances upgrades one or more virtual machines to the latest SKU set in the VM scale set model.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set.
+func (client VirtualMachineScaleSetsClient) UpdateInstances(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (result VirtualMachineScaleSetsUpdateInstancesFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.UpdateInstances")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: VMInstanceIDs,
+ Constraints: []validation.Constraint{{Target: "VMInstanceIDs.InstanceIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachineScaleSetsClient", "UpdateInstances", err.Error())
+ }
+
+ req, err := client.UpdateInstancesPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "UpdateInstances", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateInstancesSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "UpdateInstances", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateInstancesPreparer prepares the UpdateInstances request.
+func (client VirtualMachineScaleSetsClient) UpdateInstancesPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/manualupgrade", pathParameters),
+ autorest.WithJSON(VMInstanceIDs),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateInstancesSender sends the UpdateInstances request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetsClient) UpdateInstancesSender(req *http.Request) (future VirtualMachineScaleSetsUpdateInstancesFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsUpdateInstancesFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetsUpdateInstancesFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsUpdateInstancesFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.UpdateInstancesResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsUpdateInstancesFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateInstancesResponder handles the response to the UpdateInstances request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetsClient) UpdateInstancesResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetvms.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetvms.go
new file mode 100644
index 00000000000..06366b2b241
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinescalesetvms.go
@@ -0,0 +1,1393 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineScaleSetVMsClient is the compute Client
+type VirtualMachineScaleSetVMsClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineScaleSetVMsClient creates an instance of the VirtualMachineScaleSetVMsClient client.
+func NewVirtualMachineScaleSetVMsClient(subscriptionID string) VirtualMachineScaleSetVMsClient {
+ return NewVirtualMachineScaleSetVMsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineScaleSetVMsClientWithBaseURI creates an instance of the VirtualMachineScaleSetVMsClient client
+// using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
+// clouds, Azure stack).
+func NewVirtualMachineScaleSetVMsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetVMsClient {
+ return VirtualMachineScaleSetVMsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Deallocate deallocates a specific virtual machine in a VM scale set. Shuts down the virtual machine and releases the
+// compute resources it uses. You are not billed for the compute resources of this virtual machine once it is
+// deallocated.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) Deallocate(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsDeallocateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Deallocate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeallocatePreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Deallocate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeallocateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Deallocate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeallocatePreparer prepares the Deallocate request.
+func (client VirtualMachineScaleSetVMsClient) DeallocatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/deallocate", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeallocateSender sends the Deallocate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) DeallocateSender(req *http.Request) (future VirtualMachineScaleSetVMsDeallocateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsDeallocateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsDeallocateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsDeallocateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeallocateResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsDeallocateFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeallocateResponder handles the response to the Deallocate request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) DeallocateResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes a virtual machine from a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) Delete(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualMachineScaleSetVMsClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) DeleteSender(req *http.Request) (future VirtualMachineScaleSetVMsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsDeleteFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsDeleteFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.DeleteResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsDeleteFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get gets a virtual machine from a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) Get(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVM, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualMachineScaleSetVMsClient) GetPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) GetResponder(resp *http.Response) (result VirtualMachineScaleSetVM, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetInstanceView gets the status of a virtual machine from a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) GetInstanceView(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMInstanceView, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.GetInstanceView")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetInstanceViewPreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "GetInstanceView", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetInstanceViewSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "GetInstanceView", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetInstanceViewResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "GetInstanceView", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetInstanceViewPreparer prepares the GetInstanceView request.
+func (client VirtualMachineScaleSetVMsClient) GetInstanceViewPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/instanceView", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetInstanceViewSender sends the GetInstanceView request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) GetInstanceViewSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetInstanceViewResponder handles the response to the GetInstanceView request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) GetInstanceViewResponder(resp *http.Response) (result VirtualMachineScaleSetVMInstanceView, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets a list of all virtual machines in a VM scale sets.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the VM scale set.
+// filter - the filter to apply to the operation. Allowed values are 'startswith(instanceView/statuses/code,
+// 'PowerState') eq true', 'properties/latestModelApplied eq true', 'properties/latestModelApplied eq false'.
+// selectParameter - the list parameters. Allowed values are 'instanceView', 'instanceView/statuses'.
+// expand - the expand expression to apply to the operation. Allowed values are 'instanceView'.
+func (client VirtualMachineScaleSetVMsClient) List(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result VirtualMachineScaleSetVMListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.List")
+ defer func() {
+ sc := -1
+ if result.vmssvlr.Response.Response != nil {
+ sc = result.vmssvlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, filter, selectParameter, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vmssvlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vmssvlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vmssvlr.hasNextLink() && result.vmssvlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualMachineScaleSetVMsClient) ListPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = autorest.Encode("query", filter)
+ }
+ if len(selectParameter) > 0 {
+ queryParameters["$select"] = autorest.Encode("query", selectParameter)
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) ListResponder(resp *http.Response) (result VirtualMachineScaleSetVMListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualMachineScaleSetVMsClient) listNextResults(ctx context.Context, lastResults VirtualMachineScaleSetVMListResult) (result VirtualMachineScaleSetVMListResult, err error) {
+ req, err := lastResults.virtualMachineScaleSetVMListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualMachineScaleSetVMsClient) ListComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result VirtualMachineScaleSetVMListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, virtualMachineScaleSetName, filter, selectParameter, expand)
+ return
+}
+
+// PerformMaintenance performs maintenance on a virtual machine in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) PerformMaintenance(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsPerformMaintenanceFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.PerformMaintenance")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.PerformMaintenancePreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "PerformMaintenance", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.PerformMaintenanceSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "PerformMaintenance", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// PerformMaintenancePreparer prepares the PerformMaintenance request.
+func (client VirtualMachineScaleSetVMsClient) PerformMaintenancePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/performMaintenance", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// PerformMaintenanceSender sends the PerformMaintenance request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) PerformMaintenanceSender(req *http.Request) (future VirtualMachineScaleSetVMsPerformMaintenanceFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsPerformMaintenanceFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsPerformMaintenanceFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsPerformMaintenanceFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.PerformMaintenanceResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsPerformMaintenanceFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// PerformMaintenanceResponder handles the response to the PerformMaintenance request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) PerformMaintenanceResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// PowerOff power off (stop) a virtual machine in a VM scale set. Note that resources are still attached and you are
+// getting charged for the resources. Instead, use deallocate to release resources and avoid charges.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) PowerOff(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsPowerOffFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.PowerOff")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.PowerOffPreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "PowerOff", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.PowerOffSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "PowerOff", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// PowerOffPreparer prepares the PowerOff request.
+func (client VirtualMachineScaleSetVMsClient) PowerOffPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/poweroff", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// PowerOffSender sends the PowerOff request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) PowerOffSender(req *http.Request) (future VirtualMachineScaleSetVMsPowerOffFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsPowerOffFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsPowerOffFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsPowerOffFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.PowerOffResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsPowerOffFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// PowerOffResponder handles the response to the PowerOff request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) PowerOffResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Redeploy shuts down the virtual machine in the virtual machine scale set, moves it to a new node, and powers it back
+// on.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) Redeploy(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsRedeployFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Redeploy")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RedeployPreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Redeploy", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RedeploySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Redeploy", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RedeployPreparer prepares the Redeploy request.
+func (client VirtualMachineScaleSetVMsClient) RedeployPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/redeploy", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RedeploySender sends the Redeploy request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) RedeploySender(req *http.Request) (future VirtualMachineScaleSetVMsRedeployFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsRedeployFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsRedeployFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsRedeployFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RedeployResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsRedeployFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RedeployResponder handles the response to the Redeploy request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) RedeployResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Reimage reimages (upgrade the operating system) a specific virtual machine in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) Reimage(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsReimageFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Reimage")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ReimagePreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Reimage", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ReimageSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Reimage", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ReimagePreparer prepares the Reimage request.
+func (client VirtualMachineScaleSetVMsClient) ReimagePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/reimage", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ReimageSender sends the Reimage request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) ReimageSender(req *http.Request) (future VirtualMachineScaleSetVMsReimageFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsReimageFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsReimageFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsReimageFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.ReimageResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsReimageFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ReimageResponder handles the response to the Reimage request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) ReimageResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ReimageAll allows you to re-image all the disks ( including data disks ) in the a VM scale set instance. This
+// operation is only supported for managed disks.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) ReimageAll(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsReimageAllFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.ReimageAll")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ReimageAllPreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "ReimageAll", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ReimageAllSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "ReimageAll", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ReimageAllPreparer prepares the ReimageAll request.
+func (client VirtualMachineScaleSetVMsClient) ReimageAllPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/reimageall", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ReimageAllSender sends the ReimageAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) ReimageAllSender(req *http.Request) (future VirtualMachineScaleSetVMsReimageAllFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsReimageAllFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsReimageAllFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsReimageAllFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.ReimageAllResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsReimageAllFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ReimageAllResponder handles the response to the ReimageAll request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) ReimageAllResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Restart restarts a virtual machine in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) Restart(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsRestartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Restart")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.RestartPreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Restart", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.RestartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Restart", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// RestartPreparer prepares the Restart request.
+func (client VirtualMachineScaleSetVMsClient) RestartPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/restart", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RestartSender sends the Restart request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) RestartSender(req *http.Request) (future VirtualMachineScaleSetVMsRestartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsRestartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsRestartFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsRestartFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.RestartResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsRestartFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// RestartResponder handles the response to the Restart request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) RestartResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Start starts a virtual machine in a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set.
+// instanceID - the instance ID of the virtual machine.
+func (client VirtualMachineScaleSetVMsClient) Start(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result VirtualMachineScaleSetVMsStartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Start")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StartPreparer(ctx, resourceGroupName, VMScaleSetName, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Start", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Start", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StartPreparer prepares the Start request.
+func (client VirtualMachineScaleSetVMsClient) StartPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StartSender sends the Start request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) StartSender(req *http.Request) (future VirtualMachineScaleSetVMsStartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (osr OperationStatusResponse, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsStartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsStartFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ osr.Response.Response, err = future.GetResult(sender)
+ if osr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsStartFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && osr.Response.Response.StatusCode != http.StatusNoContent {
+ osr, err = client.StartResponder(osr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsStartFuture", "Result", osr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// StartResponder handles the response to the Start request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) StartResponder(resp *http.Response) (result OperationStatusResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update updates a virtual machine of a VM scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// VMScaleSetName - the name of the VM scale set where the extension should be create or updated.
+// instanceID - the instance ID of the virtual machine.
+// parameters - parameters supplied to the Update Virtual Machine Scale Sets VM operation.
+func (client VirtualMachineScaleSetVMsClient) Update(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string, parameters VirtualMachineScaleSetVM) (result VirtualMachineScaleSetVMsUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetVMsClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetVMProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk.EncryptionSettings", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey.SecretURL", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey.KeyURL", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.VirtualMachineScaleSetVMProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachineScaleSetVMsClient", "Update", err.Error())
+ }
+
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, VMScaleSetName, instanceID, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client VirtualMachineScaleSetVMsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string, parameters VirtualMachineScaleSetVM) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vmScaleSetName": autorest.Encode("path", VMScaleSetName),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ parameters.InstanceID = nil
+ parameters.Sku = nil
+ parameters.Resources = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/virtualmachines/{instanceId}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineScaleSetVMsClient) UpdateSender(req *http.Request) (future VirtualMachineScaleSetVMsUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualMachineScaleSetVMsClient) (vmssv VirtualMachineScaleSetVM, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("compute.VirtualMachineScaleSetVMsUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vmssv.Response.Response, err = future.GetResult(sender)
+ if vmssv.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vmssv.Response.Response.StatusCode != http.StatusNoContent {
+ vmssv, err = client.UpdateResponder(vmssv.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetVMsUpdateFuture", "Result", vmssv.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineScaleSetVMsClient) UpdateResponder(resp *http.Response) (result VirtualMachineScaleSetVM, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinesizes.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinesizes.go
new file mode 100644
index 00000000000..75d530d3c01
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute/virtualmachinesizes.go
@@ -0,0 +1,124 @@
+package compute
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualMachineSizesClient is the compute Client
+type VirtualMachineSizesClient struct {
+ BaseClient
+}
+
+// NewVirtualMachineSizesClient creates an instance of the VirtualMachineSizesClient client.
+func NewVirtualMachineSizesClient(subscriptionID string) VirtualMachineSizesClient {
+ return NewVirtualMachineSizesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualMachineSizesClientWithBaseURI creates an instance of the VirtualMachineSizesClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewVirtualMachineSizesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineSizesClient {
+ return VirtualMachineSizesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List lists all available virtual machine sizes for a subscription in a location.
+// Parameters:
+// location - the location upon which virtual-machine-sizes is queried.
+func (client VirtualMachineSizesClient) List(ctx context.Context, location string) (result VirtualMachineSizeListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineSizesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("compute.VirtualMachineSizesClient", "List", err.Error())
+ }
+
+ req, err := client.ListPreparer(ctx, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineSizesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineSizesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "compute.VirtualMachineSizesClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualMachineSizesClient) ListPreparer(ctx context.Context, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-12-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/vmSizes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualMachineSizesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualMachineSizesClient) ListResponder(resp *http.Response) (result VirtualMachineSizeListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/CHANGELOG.md b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/CHANGELOG.md
new file mode 100644
index 00000000000..0b2ea50a90b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/CHANGELOG.md
@@ -0,0 +1,5 @@
+Generated from https://github.com/Azure/azure-rest-api-specs/tree/3c764635e7d442b3e74caf593029fcd440b3ef82//specification/network/resource-manager/readme.md tag: `package-2017-10`
+
+Code generator @microsoft.azure/autorest.go@2.1.171
+
+
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/applicationgateways.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/applicationgateways.go
new file mode 100644
index 00000000000..2414bbe6530
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/applicationgateways.go
@@ -0,0 +1,1273 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ApplicationGatewaysClient is the network Client
+type ApplicationGatewaysClient struct {
+ BaseClient
+}
+
+// NewApplicationGatewaysClient creates an instance of the ApplicationGatewaysClient client.
+func NewApplicationGatewaysClient(subscriptionID string) ApplicationGatewaysClient {
+ return NewApplicationGatewaysClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewApplicationGatewaysClientWithBaseURI creates an instance of the ApplicationGatewaysClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewApplicationGatewaysClientWithBaseURI(baseURI string, subscriptionID string) ApplicationGatewaysClient {
+ return ApplicationGatewaysClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// BackendHealth gets the backend health of the specified application gateway in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationGatewayName - the name of the application gateway.
+// expand - expands BackendAddressPool and BackendHttpSettings referenced in backend health.
+func (client ApplicationGatewaysClient) BackendHealth(ctx context.Context, resourceGroupName string, applicationGatewayName string, expand string) (result ApplicationGatewaysBackendHealthFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.BackendHealth")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.BackendHealthPreparer(ctx, resourceGroupName, applicationGatewayName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "BackendHealth", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.BackendHealthSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "BackendHealth", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// BackendHealthPreparer prepares the BackendHealth request.
+func (client ApplicationGatewaysClient) BackendHealthPreparer(ctx context.Context, resourceGroupName string, applicationGatewayName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationGatewayName": autorest.Encode("path", applicationGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendhealth", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// BackendHealthSender sends the BackendHealth request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) BackendHealthSender(req *http.Request) (future ApplicationGatewaysBackendHealthFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationGatewaysClient) (agbh ApplicationGatewayBackendHealth, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysBackendHealthFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationGatewaysBackendHealthFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ agbh.Response.Response, err = future.GetResult(sender)
+ if agbh.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysBackendHealthFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && agbh.Response.Response.StatusCode != http.StatusNoContent {
+ agbh, err = client.BackendHealthResponder(agbh.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysBackendHealthFuture", "Result", agbh.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// BackendHealthResponder handles the response to the BackendHealth request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) BackendHealthResponder(resp *http.Response) (result ApplicationGatewayBackendHealth, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdate creates or updates the specified application gateway.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationGatewayName - the name of the application gateway.
+// parameters - parameters supplied to the create or update application gateway operation.
+func (client ApplicationGatewaysClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, applicationGatewayName string, parameters ApplicationGateway) (result ApplicationGatewaysCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.ApplicationGatewayPropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.ApplicationGatewayPropertiesFormat.WebApplicationFirewallConfiguration", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.ApplicationGatewayPropertiesFormat.WebApplicationFirewallConfiguration.Enabled", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.ApplicationGatewayPropertiesFormat.WebApplicationFirewallConfiguration.RuleSetType", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.ApplicationGatewayPropertiesFormat.WebApplicationFirewallConfiguration.RuleSetVersion", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.ApplicationGatewaysClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, applicationGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client ApplicationGatewaysClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, applicationGatewayName string, parameters ApplicationGateway) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationGatewayName": autorest.Encode("path", applicationGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) CreateOrUpdateSender(req *http.Request) (future ApplicationGatewaysCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationGatewaysClient) (ag ApplicationGateway, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationGatewaysCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ag.Response.Response, err = future.GetResult(sender)
+ if ag.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ag.Response.Response.StatusCode != http.StatusNoContent {
+ ag, err = client.CreateOrUpdateResponder(ag.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysCreateOrUpdateFuture", "Result", ag.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) CreateOrUpdateResponder(resp *http.Response) (result ApplicationGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified application gateway.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationGatewayName - the name of the application gateway.
+func (client ApplicationGatewaysClient) Delete(ctx context.Context, resourceGroupName string, applicationGatewayName string) (result ApplicationGatewaysDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, applicationGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client ApplicationGatewaysClient) DeletePreparer(ctx context.Context, resourceGroupName string, applicationGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationGatewayName": autorest.Encode("path", applicationGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) DeleteSender(req *http.Request) (future ApplicationGatewaysDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationGatewaysClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationGatewaysDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified application gateway.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationGatewayName - the name of the application gateway.
+func (client ApplicationGatewaysClient) Get(ctx context.Context, resourceGroupName string, applicationGatewayName string) (result ApplicationGateway, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, applicationGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client ApplicationGatewaysClient) GetPreparer(ctx context.Context, resourceGroupName string, applicationGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationGatewayName": autorest.Encode("path", applicationGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) GetResponder(resp *http.Response) (result ApplicationGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetSslPredefinedPolicy gets Ssl predefined policy with the specified policy name.
+// Parameters:
+// predefinedPolicyName - name of Ssl predefined policy.
+func (client ApplicationGatewaysClient) GetSslPredefinedPolicy(ctx context.Context, predefinedPolicyName string) (result ApplicationGatewaySslPredefinedPolicy, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.GetSslPredefinedPolicy")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetSslPredefinedPolicyPreparer(ctx, predefinedPolicyName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "GetSslPredefinedPolicy", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSslPredefinedPolicySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "GetSslPredefinedPolicy", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetSslPredefinedPolicyResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "GetSslPredefinedPolicy", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetSslPredefinedPolicyPreparer prepares the GetSslPredefinedPolicy request.
+func (client ApplicationGatewaysClient) GetSslPredefinedPolicyPreparer(ctx context.Context, predefinedPolicyName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "predefinedPolicyName": autorest.Encode("path", predefinedPolicyName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/applicationGatewayAvailableSslOptions/default/predefinedPolicies/{predefinedPolicyName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSslPredefinedPolicySender sends the GetSslPredefinedPolicy request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) GetSslPredefinedPolicySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetSslPredefinedPolicyResponder handles the response to the GetSslPredefinedPolicy request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) GetSslPredefinedPolicyResponder(resp *http.Response) (result ApplicationGatewaySslPredefinedPolicy, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all application gateways in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client ApplicationGatewaysClient) List(ctx context.Context, resourceGroupName string) (result ApplicationGatewayListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.List")
+ defer func() {
+ sc := -1
+ if result.aglr.Response.Response != nil {
+ sc = result.aglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.aglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.aglr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.aglr.hasNextLink() && result.aglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ApplicationGatewaysClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) ListResponder(resp *http.Response) (result ApplicationGatewayListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ApplicationGatewaysClient) listNextResults(ctx context.Context, lastResults ApplicationGatewayListResult) (result ApplicationGatewayListResult, err error) {
+ req, err := lastResults.applicationGatewayListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ApplicationGatewaysClient) ListComplete(ctx context.Context, resourceGroupName string) (result ApplicationGatewayListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all the application gateways in a subscription.
+func (client ApplicationGatewaysClient) ListAll(ctx context.Context) (result ApplicationGatewayListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.aglr.Response.Response != nil {
+ sc = result.aglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.aglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.aglr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.aglr.hasNextLink() && result.aglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client ApplicationGatewaysClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/applicationGateways", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) ListAllResponder(resp *http.Response) (result ApplicationGatewayListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client ApplicationGatewaysClient) listAllNextResults(ctx context.Context, lastResults ApplicationGatewayListResult) (result ApplicationGatewayListResult, err error) {
+ req, err := lastResults.applicationGatewayListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ApplicationGatewaysClient) ListAllComplete(ctx context.Context) (result ApplicationGatewayListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// ListAvailableSslOptions lists available Ssl options for configuring Ssl policy.
+func (client ApplicationGatewaysClient) ListAvailableSslOptions(ctx context.Context) (result ApplicationGatewayAvailableSslOptions, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.ListAvailableSslOptions")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListAvailableSslOptionsPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableSslOptions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAvailableSslOptionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableSslOptions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAvailableSslOptionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableSslOptions", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListAvailableSslOptionsPreparer prepares the ListAvailableSslOptions request.
+func (client ApplicationGatewaysClient) ListAvailableSslOptionsPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/applicationGatewayAvailableSslOptions/default", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAvailableSslOptionsSender sends the ListAvailableSslOptions request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) ListAvailableSslOptionsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAvailableSslOptionsResponder handles the response to the ListAvailableSslOptions request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) ListAvailableSslOptionsResponder(resp *http.Response) (result ApplicationGatewayAvailableSslOptions, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAvailableSslPredefinedPolicies lists all SSL predefined policies for configuring Ssl policy.
+func (client ApplicationGatewaysClient) ListAvailableSslPredefinedPolicies(ctx context.Context) (result ApplicationGatewayAvailableSslPredefinedPoliciesPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.ListAvailableSslPredefinedPolicies")
+ defer func() {
+ sc := -1
+ if result.agaspp.Response.Response != nil {
+ sc = result.agaspp.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAvailableSslPredefinedPoliciesNextResults
+ req, err := client.ListAvailableSslPredefinedPoliciesPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableSslPredefinedPolicies", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAvailableSslPredefinedPoliciesSender(req)
+ if err != nil {
+ result.agaspp.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableSslPredefinedPolicies", resp, "Failure sending request")
+ return
+ }
+
+ result.agaspp, err = client.ListAvailableSslPredefinedPoliciesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableSslPredefinedPolicies", resp, "Failure responding to request")
+ return
+ }
+ if result.agaspp.hasNextLink() && result.agaspp.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAvailableSslPredefinedPoliciesPreparer prepares the ListAvailableSslPredefinedPolicies request.
+func (client ApplicationGatewaysClient) ListAvailableSslPredefinedPoliciesPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/applicationGatewayAvailableSslOptions/default/predefinedPolicies", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAvailableSslPredefinedPoliciesSender sends the ListAvailableSslPredefinedPolicies request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) ListAvailableSslPredefinedPoliciesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAvailableSslPredefinedPoliciesResponder handles the response to the ListAvailableSslPredefinedPolicies request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) ListAvailableSslPredefinedPoliciesResponder(resp *http.Response) (result ApplicationGatewayAvailableSslPredefinedPolicies, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAvailableSslPredefinedPoliciesNextResults retrieves the next set of results, if any.
+func (client ApplicationGatewaysClient) listAvailableSslPredefinedPoliciesNextResults(ctx context.Context, lastResults ApplicationGatewayAvailableSslPredefinedPolicies) (result ApplicationGatewayAvailableSslPredefinedPolicies, err error) {
+ req, err := lastResults.applicationGatewayAvailableSslPredefinedPoliciesPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listAvailableSslPredefinedPoliciesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAvailableSslPredefinedPoliciesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listAvailableSslPredefinedPoliciesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAvailableSslPredefinedPoliciesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "listAvailableSslPredefinedPoliciesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAvailableSslPredefinedPoliciesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ApplicationGatewaysClient) ListAvailableSslPredefinedPoliciesComplete(ctx context.Context) (result ApplicationGatewayAvailableSslPredefinedPoliciesIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.ListAvailableSslPredefinedPolicies")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAvailableSslPredefinedPolicies(ctx)
+ return
+}
+
+// ListAvailableWafRuleSets lists all available web application firewall rule sets.
+func (client ApplicationGatewaysClient) ListAvailableWafRuleSets(ctx context.Context) (result ApplicationGatewayAvailableWafRuleSetsResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.ListAvailableWafRuleSets")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListAvailableWafRuleSetsPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableWafRuleSets", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAvailableWafRuleSetsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableWafRuleSets", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAvailableWafRuleSetsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "ListAvailableWafRuleSets", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListAvailableWafRuleSetsPreparer prepares the ListAvailableWafRuleSets request.
+func (client ApplicationGatewaysClient) ListAvailableWafRuleSetsPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/applicationGatewayAvailableWafRuleSets", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAvailableWafRuleSetsSender sends the ListAvailableWafRuleSets request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) ListAvailableWafRuleSetsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAvailableWafRuleSetsResponder handles the response to the ListAvailableWafRuleSets request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) ListAvailableWafRuleSetsResponder(resp *http.Response) (result ApplicationGatewayAvailableWafRuleSetsResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Start starts the specified application gateway.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationGatewayName - the name of the application gateway.
+func (client ApplicationGatewaysClient) Start(ctx context.Context, resourceGroupName string, applicationGatewayName string) (result ApplicationGatewaysStartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.Start")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StartPreparer(ctx, resourceGroupName, applicationGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Start", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Start", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StartPreparer prepares the Start request.
+func (client ApplicationGatewaysClient) StartPreparer(ctx context.Context, resourceGroupName string, applicationGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationGatewayName": autorest.Encode("path", applicationGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StartSender sends the Start request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) StartSender(req *http.Request) (future ApplicationGatewaysStartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationGatewaysClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysStartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationGatewaysStartFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// StartResponder handles the response to the Start request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) StartResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Stop stops the specified application gateway in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationGatewayName - the name of the application gateway.
+func (client ApplicationGatewaysClient) Stop(ctx context.Context, resourceGroupName string, applicationGatewayName string) (result ApplicationGatewaysStopFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.Stop")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StopPreparer(ctx, resourceGroupName, applicationGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Stop", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StopSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "Stop", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StopPreparer prepares the Stop request.
+func (client ApplicationGatewaysClient) StopPreparer(ctx context.Context, resourceGroupName string, applicationGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationGatewayName": autorest.Encode("path", applicationGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/stop", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StopSender sends the Stop request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) StopSender(req *http.Request) (future ApplicationGatewaysStopFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationGatewaysClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysStopFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationGatewaysStopFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// StopResponder handles the response to the Stop request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) StopResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// UpdateTags updates the specified application gateway tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationGatewayName - the name of the application gateway.
+// parameters - parameters supplied to update application gateway tags.
+func (client ApplicationGatewaysClient) UpdateTags(ctx context.Context, resourceGroupName string, applicationGatewayName string, parameters TagsObject) (result ApplicationGatewaysUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewaysClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, applicationGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client ApplicationGatewaysClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, applicationGatewayName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationGatewayName": autorest.Encode("path", applicationGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationGatewaysClient) UpdateTagsSender(req *http.Request) (future ApplicationGatewaysUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationGatewaysClient) (ag ApplicationGateway, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationGatewaysUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ag.Response.Response, err = future.GetResult(sender)
+ if ag.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ag.Response.Response.StatusCode != http.StatusNoContent {
+ ag, err = client.UpdateTagsResponder(ag.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationGatewaysUpdateTagsFuture", "Result", ag.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client ApplicationGatewaysClient) UpdateTagsResponder(resp *http.Response) (result ApplicationGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/applicationsecuritygroups.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/applicationsecuritygroups.go
new file mode 100644
index 00000000000..33db013a862
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/applicationsecuritygroups.go
@@ -0,0 +1,543 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ApplicationSecurityGroupsClient is the network Client
+type ApplicationSecurityGroupsClient struct {
+ BaseClient
+}
+
+// NewApplicationSecurityGroupsClient creates an instance of the ApplicationSecurityGroupsClient client.
+func NewApplicationSecurityGroupsClient(subscriptionID string) ApplicationSecurityGroupsClient {
+ return NewApplicationSecurityGroupsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewApplicationSecurityGroupsClientWithBaseURI creates an instance of the ApplicationSecurityGroupsClient client
+// using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
+// clouds, Azure stack).
+func NewApplicationSecurityGroupsClientWithBaseURI(baseURI string, subscriptionID string) ApplicationSecurityGroupsClient {
+ return ApplicationSecurityGroupsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates an application security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationSecurityGroupName - the name of the application security group.
+// parameters - parameters supplied to the create or update ApplicationSecurityGroup operation.
+func (client ApplicationSecurityGroupsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string, parameters ApplicationSecurityGroup) (result ApplicationSecurityGroupsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, applicationSecurityGroupName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client ApplicationSecurityGroupsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string, parameters ApplicationSecurityGroup) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationSecurityGroupName": autorest.Encode("path", applicationSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ parameters.Etag = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationSecurityGroupsClient) CreateOrUpdateSender(req *http.Request) (future ApplicationSecurityGroupsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationSecurityGroupsClient) (asg ApplicationSecurityGroup, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationSecurityGroupsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ asg.Response.Response, err = future.GetResult(sender)
+ if asg.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && asg.Response.Response.StatusCode != http.StatusNoContent {
+ asg, err = client.CreateOrUpdateResponder(asg.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsCreateOrUpdateFuture", "Result", asg.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client ApplicationSecurityGroupsClient) CreateOrUpdateResponder(resp *http.Response) (result ApplicationSecurityGroup, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified application security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationSecurityGroupName - the name of the application security group.
+func (client ApplicationSecurityGroupsClient) Delete(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string) (result ApplicationSecurityGroupsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, applicationSecurityGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client ApplicationSecurityGroupsClient) DeletePreparer(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationSecurityGroupName": autorest.Encode("path", applicationSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationSecurityGroupsClient) DeleteSender(req *http.Request) (future ApplicationSecurityGroupsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ApplicationSecurityGroupsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ApplicationSecurityGroupsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client ApplicationSecurityGroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets information about the specified application security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// applicationSecurityGroupName - the name of the application security group.
+func (client ApplicationSecurityGroupsClient) Get(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string) (result ApplicationSecurityGroup, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, applicationSecurityGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client ApplicationSecurityGroupsClient) GetPreparer(ctx context.Context, resourceGroupName string, applicationSecurityGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "applicationSecurityGroupName": autorest.Encode("path", applicationSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationSecurityGroupsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client ApplicationSecurityGroupsClient) GetResponder(resp *http.Response) (result ApplicationSecurityGroup, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the application security groups in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client ApplicationSecurityGroupsClient) List(ctx context.Context, resourceGroupName string) (result ApplicationSecurityGroupListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupsClient.List")
+ defer func() {
+ sc := -1
+ if result.asglr.Response.Response != nil {
+ sc = result.asglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.asglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.asglr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.asglr.hasNextLink() && result.asglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ApplicationSecurityGroupsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationSecurityGroupsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ApplicationSecurityGroupsClient) ListResponder(resp *http.Response) (result ApplicationSecurityGroupListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ApplicationSecurityGroupsClient) listNextResults(ctx context.Context, lastResults ApplicationSecurityGroupListResult) (result ApplicationSecurityGroupListResult, err error) {
+ req, err := lastResults.applicationSecurityGroupListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ApplicationSecurityGroupsClient) ListComplete(ctx context.Context, resourceGroupName string) (result ApplicationSecurityGroupListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all application security groups in a subscription.
+func (client ApplicationSecurityGroupsClient) ListAll(ctx context.Context) (result ApplicationSecurityGroupListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.asglr.Response.Response != nil {
+ sc = result.asglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.asglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.asglr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.asglr.hasNextLink() && result.asglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client ApplicationSecurityGroupsClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/applicationSecurityGroups", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client ApplicationSecurityGroupsClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client ApplicationSecurityGroupsClient) ListAllResponder(resp *http.Response) (result ApplicationSecurityGroupListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client ApplicationSecurityGroupsClient) listAllNextResults(ctx context.Context, lastResults ApplicationSecurityGroupListResult) (result ApplicationSecurityGroupListResult, err error) {
+ req, err := lastResults.applicationSecurityGroupListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ApplicationSecurityGroupsClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ApplicationSecurityGroupsClient) ListAllComplete(ctx context.Context) (result ApplicationSecurityGroupListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/availableendpointservices.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/availableendpointservices.go
new file mode 100644
index 00000000000..7cf2eee63fc
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/availableendpointservices.go
@@ -0,0 +1,159 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// AvailableEndpointServicesClient is the network Client
+type AvailableEndpointServicesClient struct {
+ BaseClient
+}
+
+// NewAvailableEndpointServicesClient creates an instance of the AvailableEndpointServicesClient client.
+func NewAvailableEndpointServicesClient(subscriptionID string) AvailableEndpointServicesClient {
+ return NewAvailableEndpointServicesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewAvailableEndpointServicesClientWithBaseURI creates an instance of the AvailableEndpointServicesClient client
+// using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
+// clouds, Azure stack).
+func NewAvailableEndpointServicesClientWithBaseURI(baseURI string, subscriptionID string) AvailableEndpointServicesClient {
+ return AvailableEndpointServicesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List list what values of endpoint services are available for use.
+// Parameters:
+// location - the location to check available endpoint services.
+func (client AvailableEndpointServicesClient) List(ctx context.Context, location string) (result EndpointServicesListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailableEndpointServicesClient.List")
+ defer func() {
+ sc := -1
+ if result.eslr.Response.Response != nil {
+ sc = result.eslr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.AvailableEndpointServicesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.eslr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.AvailableEndpointServicesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.eslr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.AvailableEndpointServicesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.eslr.hasNextLink() && result.eslr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client AvailableEndpointServicesClient) ListPreparer(ctx context.Context, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/locations/{location}/virtualNetworkAvailableEndpointServices", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client AvailableEndpointServicesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client AvailableEndpointServicesClient) ListResponder(resp *http.Response) (result EndpointServicesListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client AvailableEndpointServicesClient) listNextResults(ctx context.Context, lastResults EndpointServicesListResult) (result EndpointServicesListResult, err error) {
+ req, err := lastResults.endpointServicesListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.AvailableEndpointServicesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.AvailableEndpointServicesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.AvailableEndpointServicesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client AvailableEndpointServicesClient) ListComplete(ctx context.Context, location string) (result EndpointServicesListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AvailableEndpointServicesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, location)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/bgpservicecommunities.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/bgpservicecommunities.go
new file mode 100644
index 00000000000..33b3ebb934d
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/bgpservicecommunities.go
@@ -0,0 +1,156 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// BgpServiceCommunitiesClient is the network Client
+type BgpServiceCommunitiesClient struct {
+ BaseClient
+}
+
+// NewBgpServiceCommunitiesClient creates an instance of the BgpServiceCommunitiesClient client.
+func NewBgpServiceCommunitiesClient(subscriptionID string) BgpServiceCommunitiesClient {
+ return NewBgpServiceCommunitiesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewBgpServiceCommunitiesClientWithBaseURI creates an instance of the BgpServiceCommunitiesClient client using a
+// custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds,
+// Azure stack).
+func NewBgpServiceCommunitiesClientWithBaseURI(baseURI string, subscriptionID string) BgpServiceCommunitiesClient {
+ return BgpServiceCommunitiesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List gets all the available bgp service communities.
+func (client BgpServiceCommunitiesClient) List(ctx context.Context) (result BgpServiceCommunityListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/BgpServiceCommunitiesClient.List")
+ defer func() {
+ sc := -1
+ if result.bsclr.Response.Response != nil {
+ sc = result.bsclr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.BgpServiceCommunitiesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.bsclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.BgpServiceCommunitiesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.bsclr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.BgpServiceCommunitiesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.bsclr.hasNextLink() && result.bsclr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client BgpServiceCommunitiesClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/bgpServiceCommunities", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client BgpServiceCommunitiesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client BgpServiceCommunitiesClient) ListResponder(resp *http.Response) (result BgpServiceCommunityListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client BgpServiceCommunitiesClient) listNextResults(ctx context.Context, lastResults BgpServiceCommunityListResult) (result BgpServiceCommunityListResult, err error) {
+ req, err := lastResults.bgpServiceCommunityListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.BgpServiceCommunitiesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.BgpServiceCommunitiesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.BgpServiceCommunitiesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client BgpServiceCommunitiesClient) ListComplete(ctx context.Context) (result BgpServiceCommunityListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/BgpServiceCommunitiesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/client.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/client.go
new file mode 100644
index 00000000000..8e44312029b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/client.go
@@ -0,0 +1,133 @@
+// Package network implements the Azure ARM Network service API version .
+//
+// Network Client
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+const (
+ // DefaultBaseURI is the default URI used for the service Network
+ DefaultBaseURI = "https://management.azure.com"
+)
+
+// BaseClient is the base client for Network.
+type BaseClient struct {
+ autorest.Client
+ BaseURI string
+ SubscriptionID string
+}
+
+// New creates an instance of the BaseClient client.
+func New(subscriptionID string) BaseClient {
+ return NewWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint. Use this when interacting with
+// an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+ return BaseClient{
+ Client: autorest.NewClientWithUserAgent(UserAgent()),
+ BaseURI: baseURI,
+ SubscriptionID: subscriptionID,
+ }
+}
+
+// CheckDNSNameAvailability checks whether a domain name in the cloudapp.azure.com zone is available for use.
+// Parameters:
+// location - the location of the domain name.
+// domainNameLabel - the domain name to be verified. It must conform to the following regular expression:
+// ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.
+func (client BaseClient) CheckDNSNameAvailability(ctx context.Context, location string, domainNameLabel string) (result DNSNameAvailabilityResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CheckDNSNameAvailability")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CheckDNSNameAvailabilityPreparer(ctx, location, domainNameLabel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.BaseClient", "CheckDNSNameAvailability", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CheckDNSNameAvailabilitySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.BaseClient", "CheckDNSNameAvailability", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CheckDNSNameAvailabilityResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.BaseClient", "CheckDNSNameAvailability", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// CheckDNSNameAvailabilityPreparer prepares the CheckDNSNameAvailability request.
+func (client BaseClient) CheckDNSNameAvailabilityPreparer(ctx context.Context, location string, domainNameLabel string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ "domainNameLabel": autorest.Encode("query", domainNameLabel),
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/locations/{location}/CheckDnsNameAvailability", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CheckDNSNameAvailabilitySender sends the CheckDNSNameAvailability request. The method will close the
+// http.Response Body if it receives an error.
+func (client BaseClient) CheckDNSNameAvailabilitySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// CheckDNSNameAvailabilityResponder handles the response to the CheckDNSNameAvailability request. The method always
+// closes the http.Response Body.
+func (client BaseClient) CheckDNSNameAvailabilityResponder(resp *http.Response) (result DNSNameAvailabilityResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/connectionmonitors.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/connectionmonitors.go
new file mode 100644
index 00000000000..f4c550b0064
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/connectionmonitors.go
@@ -0,0 +1,693 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ConnectionMonitorsClient is the network Client
+type ConnectionMonitorsClient struct {
+ BaseClient
+}
+
+// NewConnectionMonitorsClient creates an instance of the ConnectionMonitorsClient client.
+func NewConnectionMonitorsClient(subscriptionID string) ConnectionMonitorsClient {
+ return NewConnectionMonitorsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewConnectionMonitorsClientWithBaseURI creates an instance of the ConnectionMonitorsClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewConnectionMonitorsClientWithBaseURI(baseURI string, subscriptionID string) ConnectionMonitorsClient {
+ return ConnectionMonitorsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or update a connection monitor.
+// Parameters:
+// resourceGroupName - the name of the resource group containing Network Watcher.
+// networkWatcherName - the name of the Network Watcher resource.
+// connectionMonitorName - the name of the connection monitor.
+// parameters - parameters that define the operation to create a connection monitor.
+func (client ConnectionMonitorsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, parameters ConnectionMonitor) (result ConnectionMonitorsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ConnectionMonitorsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.ConnectionMonitorParameters", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.ConnectionMonitorParameters.Source", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.ConnectionMonitorParameters.Source.ResourceID", Name: validation.Null, Rule: true, Chain: nil}}},
+ {Target: "parameters.ConnectionMonitorParameters.Destination", Name: validation.Null, Rule: true, Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.ConnectionMonitorsClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, networkWatcherName, connectionMonitorName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client ConnectionMonitorsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string, parameters ConnectionMonitor) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "connectionMonitorName": autorest.Encode("path", connectionMonitorName),
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectionMonitors/{connectionMonitorName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ConnectionMonitorsClient) CreateOrUpdateSender(req *http.Request) (future ConnectionMonitorsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ConnectionMonitorsClient) (cmr ConnectionMonitorResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ConnectionMonitorsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ cmr.Response.Response, err = future.GetResult(sender)
+ if cmr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && cmr.Response.Response.StatusCode != http.StatusNoContent {
+ cmr, err = client.CreateOrUpdateResponder(cmr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsCreateOrUpdateFuture", "Result", cmr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client ConnectionMonitorsClient) CreateOrUpdateResponder(resp *http.Response) (result ConnectionMonitorResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified connection monitor.
+// Parameters:
+// resourceGroupName - the name of the resource group containing Network Watcher.
+// networkWatcherName - the name of the Network Watcher resource.
+// connectionMonitorName - the name of the connection monitor.
+func (client ConnectionMonitorsClient) Delete(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (result ConnectionMonitorsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ConnectionMonitorsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, networkWatcherName, connectionMonitorName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client ConnectionMonitorsClient) DeletePreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "connectionMonitorName": autorest.Encode("path", connectionMonitorName),
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectionMonitors/{connectionMonitorName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client ConnectionMonitorsClient) DeleteSender(req *http.Request) (future ConnectionMonitorsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ConnectionMonitorsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ConnectionMonitorsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client ConnectionMonitorsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets a connection monitor by name.
+// Parameters:
+// resourceGroupName - the name of the resource group containing Network Watcher.
+// networkWatcherName - the name of the Network Watcher resource.
+// connectionMonitorName - the name of the connection monitor.
+func (client ConnectionMonitorsClient) Get(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (result ConnectionMonitorResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ConnectionMonitorsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkWatcherName, connectionMonitorName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client ConnectionMonitorsClient) GetPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "connectionMonitorName": autorest.Encode("path", connectionMonitorName),
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectionMonitors/{connectionMonitorName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client ConnectionMonitorsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client ConnectionMonitorsClient) GetResponder(resp *http.Response) (result ConnectionMonitorResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all connection monitors for the specified Network Watcher.
+// Parameters:
+// resourceGroupName - the name of the resource group containing Network Watcher.
+// networkWatcherName - the name of the Network Watcher resource.
+func (client ConnectionMonitorsClient) List(ctx context.Context, resourceGroupName string, networkWatcherName string) (result ConnectionMonitorListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ConnectionMonitorsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx, resourceGroupName, networkWatcherName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ConnectionMonitorsClient) ListPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectionMonitors", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ConnectionMonitorsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ConnectionMonitorsClient) ListResponder(resp *http.Response) (result ConnectionMonitorListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Query query a snapshot of the most recent connection states.
+// Parameters:
+// resourceGroupName - the name of the resource group containing Network Watcher.
+// networkWatcherName - the name of the Network Watcher resource.
+// connectionMonitorName - the name given to the connection monitor.
+func (client ConnectionMonitorsClient) Query(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (result ConnectionMonitorsQueryFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ConnectionMonitorsClient.Query")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.QueryPreparer(ctx, resourceGroupName, networkWatcherName, connectionMonitorName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Query", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.QuerySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Query", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// QueryPreparer prepares the Query request.
+func (client ConnectionMonitorsClient) QueryPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "connectionMonitorName": autorest.Encode("path", connectionMonitorName),
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectionMonitors/{connectionMonitorName}/query", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// QuerySender sends the Query request. The method will close the
+// http.Response Body if it receives an error.
+func (client ConnectionMonitorsClient) QuerySender(req *http.Request) (future ConnectionMonitorsQueryFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ConnectionMonitorsClient) (cmqr ConnectionMonitorQueryResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsQueryFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ConnectionMonitorsQueryFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ cmqr.Response.Response, err = future.GetResult(sender)
+ if cmqr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsQueryFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && cmqr.Response.Response.StatusCode != http.StatusNoContent {
+ cmqr, err = client.QueryResponder(cmqr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsQueryFuture", "Result", cmqr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// QueryResponder handles the response to the Query request. The method always
+// closes the http.Response Body.
+func (client ConnectionMonitorsClient) QueryResponder(resp *http.Response) (result ConnectionMonitorQueryResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Start starts the specified connection monitor.
+// Parameters:
+// resourceGroupName - the name of the resource group containing Network Watcher.
+// networkWatcherName - the name of the Network Watcher resource.
+// connectionMonitorName - the name of the connection monitor.
+func (client ConnectionMonitorsClient) Start(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (result ConnectionMonitorsStartFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ConnectionMonitorsClient.Start")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StartPreparer(ctx, resourceGroupName, networkWatcherName, connectionMonitorName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Start", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StartSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Start", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StartPreparer prepares the Start request.
+func (client ConnectionMonitorsClient) StartPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "connectionMonitorName": autorest.Encode("path", connectionMonitorName),
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectionMonitors/{connectionMonitorName}/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StartSender sends the Start request. The method will close the
+// http.Response Body if it receives an error.
+func (client ConnectionMonitorsClient) StartSender(req *http.Request) (future ConnectionMonitorsStartFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ConnectionMonitorsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsStartFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ConnectionMonitorsStartFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// StartResponder handles the response to the Start request. The method always
+// closes the http.Response Body.
+func (client ConnectionMonitorsClient) StartResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Stop stops the specified connection monitor.
+// Parameters:
+// resourceGroupName - the name of the resource group containing Network Watcher.
+// networkWatcherName - the name of the Network Watcher resource.
+// connectionMonitorName - the name of the connection monitor.
+func (client ConnectionMonitorsClient) Stop(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (result ConnectionMonitorsStopFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ConnectionMonitorsClient.Stop")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StopPreparer(ctx, resourceGroupName, networkWatcherName, connectionMonitorName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Stop", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StopSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsClient", "Stop", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StopPreparer prepares the Stop request.
+func (client ConnectionMonitorsClient) StopPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, connectionMonitorName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "connectionMonitorName": autorest.Encode("path", connectionMonitorName),
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectionMonitors/{connectionMonitorName}/stop", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StopSender sends the Stop request. The method will close the
+// http.Response Body if it receives an error.
+func (client ConnectionMonitorsClient) StopSender(req *http.Request) (future ConnectionMonitorsStopFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ConnectionMonitorsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ConnectionMonitorsStopFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ConnectionMonitorsStopFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// StopResponder handles the response to the Stop request. The method always
+// closes the http.Response Body.
+func (client ConnectionMonitorsClient) StopResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/defaultsecurityrules.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/defaultsecurityrules.go
new file mode 100644
index 00000000000..8c1e456325a
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/defaultsecurityrules.go
@@ -0,0 +1,239 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// DefaultSecurityRulesClient is the network Client
+type DefaultSecurityRulesClient struct {
+ BaseClient
+}
+
+// NewDefaultSecurityRulesClient creates an instance of the DefaultSecurityRulesClient client.
+func NewDefaultSecurityRulesClient(subscriptionID string) DefaultSecurityRulesClient {
+ return NewDefaultSecurityRulesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewDefaultSecurityRulesClientWithBaseURI creates an instance of the DefaultSecurityRulesClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewDefaultSecurityRulesClientWithBaseURI(baseURI string, subscriptionID string) DefaultSecurityRulesClient {
+ return DefaultSecurityRulesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get get the specified default network security rule.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+// defaultSecurityRuleName - the name of the default security rule.
+func (client DefaultSecurityRulesClient) Get(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, defaultSecurityRuleName string) (result SecurityRule, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DefaultSecurityRulesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkSecurityGroupName, defaultSecurityRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client DefaultSecurityRulesClient) GetPreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, defaultSecurityRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "defaultSecurityRuleName": autorest.Encode("path", defaultSecurityRuleName),
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}/defaultSecurityRules/{defaultSecurityRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client DefaultSecurityRulesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client DefaultSecurityRulesClient) GetResponder(resp *http.Response) (result SecurityRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all default security rules in a network security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+func (client DefaultSecurityRulesClient) List(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (result SecurityRuleListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DefaultSecurityRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.srlr.Response.Response != nil {
+ sc = result.srlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, networkSecurityGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.srlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.srlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.srlr.hasNextLink() && result.srlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client DefaultSecurityRulesClient) ListPreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}/defaultSecurityRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client DefaultSecurityRulesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client DefaultSecurityRulesClient) ListResponder(resp *http.Response) (result SecurityRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client DefaultSecurityRulesClient) listNextResults(ctx context.Context, lastResults SecurityRuleListResult) (result SecurityRuleListResult, err error) {
+ req, err := lastResults.securityRuleListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.DefaultSecurityRulesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client DefaultSecurityRulesClient) ListComplete(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (result SecurityRuleListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/DefaultSecurityRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, networkSecurityGroupName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/enums.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/enums.go
new file mode 100644
index 00000000000..01df48a6322
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/enums.go
@@ -0,0 +1,1272 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// Access enumerates the values for access.
+type Access string
+
+const (
+ // Allow ...
+ Allow Access = "Allow"
+ // Deny ...
+ Deny Access = "Deny"
+)
+
+// PossibleAccessValues returns an array of possible values for the Access const type.
+func PossibleAccessValues() []Access {
+ return []Access{Allow, Deny}
+}
+
+// ApplicationGatewayBackendHealthServerHealth enumerates the values for application gateway backend health
+// server health.
+type ApplicationGatewayBackendHealthServerHealth string
+
+const (
+ // Down ...
+ Down ApplicationGatewayBackendHealthServerHealth = "Down"
+ // Draining ...
+ Draining ApplicationGatewayBackendHealthServerHealth = "Draining"
+ // Partial ...
+ Partial ApplicationGatewayBackendHealthServerHealth = "Partial"
+ // Unknown ...
+ Unknown ApplicationGatewayBackendHealthServerHealth = "Unknown"
+ // Up ...
+ Up ApplicationGatewayBackendHealthServerHealth = "Up"
+)
+
+// PossibleApplicationGatewayBackendHealthServerHealthValues returns an array of possible values for the ApplicationGatewayBackendHealthServerHealth const type.
+func PossibleApplicationGatewayBackendHealthServerHealthValues() []ApplicationGatewayBackendHealthServerHealth {
+ return []ApplicationGatewayBackendHealthServerHealth{Down, Draining, Partial, Unknown, Up}
+}
+
+// ApplicationGatewayCookieBasedAffinity enumerates the values for application gateway cookie based affinity.
+type ApplicationGatewayCookieBasedAffinity string
+
+const (
+ // Disabled ...
+ Disabled ApplicationGatewayCookieBasedAffinity = "Disabled"
+ // Enabled ...
+ Enabled ApplicationGatewayCookieBasedAffinity = "Enabled"
+)
+
+// PossibleApplicationGatewayCookieBasedAffinityValues returns an array of possible values for the ApplicationGatewayCookieBasedAffinity const type.
+func PossibleApplicationGatewayCookieBasedAffinityValues() []ApplicationGatewayCookieBasedAffinity {
+ return []ApplicationGatewayCookieBasedAffinity{Disabled, Enabled}
+}
+
+// ApplicationGatewayFirewallMode enumerates the values for application gateway firewall mode.
+type ApplicationGatewayFirewallMode string
+
+const (
+ // Detection ...
+ Detection ApplicationGatewayFirewallMode = "Detection"
+ // Prevention ...
+ Prevention ApplicationGatewayFirewallMode = "Prevention"
+)
+
+// PossibleApplicationGatewayFirewallModeValues returns an array of possible values for the ApplicationGatewayFirewallMode const type.
+func PossibleApplicationGatewayFirewallModeValues() []ApplicationGatewayFirewallMode {
+ return []ApplicationGatewayFirewallMode{Detection, Prevention}
+}
+
+// ApplicationGatewayOperationalState enumerates the values for application gateway operational state.
+type ApplicationGatewayOperationalState string
+
+const (
+ // Running ...
+ Running ApplicationGatewayOperationalState = "Running"
+ // Starting ...
+ Starting ApplicationGatewayOperationalState = "Starting"
+ // Stopped ...
+ Stopped ApplicationGatewayOperationalState = "Stopped"
+ // Stopping ...
+ Stopping ApplicationGatewayOperationalState = "Stopping"
+)
+
+// PossibleApplicationGatewayOperationalStateValues returns an array of possible values for the ApplicationGatewayOperationalState const type.
+func PossibleApplicationGatewayOperationalStateValues() []ApplicationGatewayOperationalState {
+ return []ApplicationGatewayOperationalState{Running, Starting, Stopped, Stopping}
+}
+
+// ApplicationGatewayProtocol enumerates the values for application gateway protocol.
+type ApplicationGatewayProtocol string
+
+const (
+ // HTTP ...
+ HTTP ApplicationGatewayProtocol = "Http"
+ // HTTPS ...
+ HTTPS ApplicationGatewayProtocol = "Https"
+)
+
+// PossibleApplicationGatewayProtocolValues returns an array of possible values for the ApplicationGatewayProtocol const type.
+func PossibleApplicationGatewayProtocolValues() []ApplicationGatewayProtocol {
+ return []ApplicationGatewayProtocol{HTTP, HTTPS}
+}
+
+// ApplicationGatewayRedirectType enumerates the values for application gateway redirect type.
+type ApplicationGatewayRedirectType string
+
+const (
+ // Found ...
+ Found ApplicationGatewayRedirectType = "Found"
+ // Permanent ...
+ Permanent ApplicationGatewayRedirectType = "Permanent"
+ // SeeOther ...
+ SeeOther ApplicationGatewayRedirectType = "SeeOther"
+ // Temporary ...
+ Temporary ApplicationGatewayRedirectType = "Temporary"
+)
+
+// PossibleApplicationGatewayRedirectTypeValues returns an array of possible values for the ApplicationGatewayRedirectType const type.
+func PossibleApplicationGatewayRedirectTypeValues() []ApplicationGatewayRedirectType {
+ return []ApplicationGatewayRedirectType{Found, Permanent, SeeOther, Temporary}
+}
+
+// ApplicationGatewayRequestRoutingRuleType enumerates the values for application gateway request routing rule
+// type.
+type ApplicationGatewayRequestRoutingRuleType string
+
+const (
+ // Basic ...
+ Basic ApplicationGatewayRequestRoutingRuleType = "Basic"
+ // PathBasedRouting ...
+ PathBasedRouting ApplicationGatewayRequestRoutingRuleType = "PathBasedRouting"
+)
+
+// PossibleApplicationGatewayRequestRoutingRuleTypeValues returns an array of possible values for the ApplicationGatewayRequestRoutingRuleType const type.
+func PossibleApplicationGatewayRequestRoutingRuleTypeValues() []ApplicationGatewayRequestRoutingRuleType {
+ return []ApplicationGatewayRequestRoutingRuleType{Basic, PathBasedRouting}
+}
+
+// ApplicationGatewaySkuName enumerates the values for application gateway sku name.
+type ApplicationGatewaySkuName string
+
+const (
+ // StandardLarge ...
+ StandardLarge ApplicationGatewaySkuName = "Standard_Large"
+ // StandardMedium ...
+ StandardMedium ApplicationGatewaySkuName = "Standard_Medium"
+ // StandardSmall ...
+ StandardSmall ApplicationGatewaySkuName = "Standard_Small"
+ // WAFLarge ...
+ WAFLarge ApplicationGatewaySkuName = "WAF_Large"
+ // WAFMedium ...
+ WAFMedium ApplicationGatewaySkuName = "WAF_Medium"
+)
+
+// PossibleApplicationGatewaySkuNameValues returns an array of possible values for the ApplicationGatewaySkuName const type.
+func PossibleApplicationGatewaySkuNameValues() []ApplicationGatewaySkuName {
+ return []ApplicationGatewaySkuName{StandardLarge, StandardMedium, StandardSmall, WAFLarge, WAFMedium}
+}
+
+// ApplicationGatewaySslCipherSuite enumerates the values for application gateway ssl cipher suite.
+type ApplicationGatewaySslCipherSuite string
+
+const (
+ // TLSDHEDSSWITH3DESEDECBCSHA ...
+ TLSDHEDSSWITH3DESEDECBCSHA ApplicationGatewaySslCipherSuite = "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"
+ // TLSDHEDSSWITHAES128CBCSHA ...
+ TLSDHEDSSWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"
+ // TLSDHEDSSWITHAES128CBCSHA256 ...
+ TLSDHEDSSWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"
+ // TLSDHEDSSWITHAES256CBCSHA ...
+ TLSDHEDSSWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"
+ // TLSDHEDSSWITHAES256CBCSHA256 ...
+ TLSDHEDSSWITHAES256CBCSHA256 ApplicationGatewaySslCipherSuite = "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"
+ // TLSDHERSAWITHAES128CBCSHA ...
+ TLSDHERSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"
+ // TLSDHERSAWITHAES128GCMSHA256 ...
+ TLSDHERSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"
+ // TLSDHERSAWITHAES256CBCSHA ...
+ TLSDHERSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"
+ // TLSDHERSAWITHAES256GCMSHA384 ...
+ TLSDHERSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"
+ // TLSECDHEECDSAWITHAES128CBCSHA ...
+ TLSECDHEECDSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
+ // TLSECDHEECDSAWITHAES128CBCSHA256 ...
+ TLSECDHEECDSAWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
+ // TLSECDHEECDSAWITHAES128GCMSHA256 ...
+ TLSECDHEECDSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
+ // TLSECDHEECDSAWITHAES256CBCSHA ...
+ TLSECDHEECDSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
+ // TLSECDHEECDSAWITHAES256CBCSHA384 ...
+ TLSECDHEECDSAWITHAES256CBCSHA384 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
+ // TLSECDHEECDSAWITHAES256GCMSHA384 ...
+ TLSECDHEECDSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
+ // TLSECDHERSAWITHAES128CBCSHA ...
+ TLSECDHERSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
+ // TLSECDHERSAWITHAES128CBCSHA256 ...
+ TLSECDHERSAWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
+ // TLSECDHERSAWITHAES128GCMSHA256 ...
+ TLSECDHERSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
+ // TLSECDHERSAWITHAES256CBCSHA ...
+ TLSECDHERSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
+ // TLSECDHERSAWITHAES256CBCSHA384 ...
+ TLSECDHERSAWITHAES256CBCSHA384 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
+ // TLSECDHERSAWITHAES256GCMSHA384 ...
+ TLSECDHERSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
+ // TLSRSAWITH3DESEDECBCSHA ...
+ TLSRSAWITH3DESEDECBCSHA ApplicationGatewaySslCipherSuite = "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
+ // TLSRSAWITHAES128CBCSHA ...
+ TLSRSAWITHAES128CBCSHA ApplicationGatewaySslCipherSuite = "TLS_RSA_WITH_AES_128_CBC_SHA"
+ // TLSRSAWITHAES128CBCSHA256 ...
+ TLSRSAWITHAES128CBCSHA256 ApplicationGatewaySslCipherSuite = "TLS_RSA_WITH_AES_128_CBC_SHA256"
+ // TLSRSAWITHAES128GCMSHA256 ...
+ TLSRSAWITHAES128GCMSHA256 ApplicationGatewaySslCipherSuite = "TLS_RSA_WITH_AES_128_GCM_SHA256"
+ // TLSRSAWITHAES256CBCSHA ...
+ TLSRSAWITHAES256CBCSHA ApplicationGatewaySslCipherSuite = "TLS_RSA_WITH_AES_256_CBC_SHA"
+ // TLSRSAWITHAES256CBCSHA256 ...
+ TLSRSAWITHAES256CBCSHA256 ApplicationGatewaySslCipherSuite = "TLS_RSA_WITH_AES_256_CBC_SHA256"
+ // TLSRSAWITHAES256GCMSHA384 ...
+ TLSRSAWITHAES256GCMSHA384 ApplicationGatewaySslCipherSuite = "TLS_RSA_WITH_AES_256_GCM_SHA384"
+)
+
+// PossibleApplicationGatewaySslCipherSuiteValues returns an array of possible values for the ApplicationGatewaySslCipherSuite const type.
+func PossibleApplicationGatewaySslCipherSuiteValues() []ApplicationGatewaySslCipherSuite {
+ return []ApplicationGatewaySslCipherSuite{TLSDHEDSSWITH3DESEDECBCSHA, TLSDHEDSSWITHAES128CBCSHA, TLSDHEDSSWITHAES128CBCSHA256, TLSDHEDSSWITHAES256CBCSHA, TLSDHEDSSWITHAES256CBCSHA256, TLSDHERSAWITHAES128CBCSHA, TLSDHERSAWITHAES128GCMSHA256, TLSDHERSAWITHAES256CBCSHA, TLSDHERSAWITHAES256GCMSHA384, TLSECDHEECDSAWITHAES128CBCSHA, TLSECDHEECDSAWITHAES128CBCSHA256, TLSECDHEECDSAWITHAES128GCMSHA256, TLSECDHEECDSAWITHAES256CBCSHA, TLSECDHEECDSAWITHAES256CBCSHA384, TLSECDHEECDSAWITHAES256GCMSHA384, TLSECDHERSAWITHAES128CBCSHA, TLSECDHERSAWITHAES128CBCSHA256, TLSECDHERSAWITHAES128GCMSHA256, TLSECDHERSAWITHAES256CBCSHA, TLSECDHERSAWITHAES256CBCSHA384, TLSECDHERSAWITHAES256GCMSHA384, TLSRSAWITH3DESEDECBCSHA, TLSRSAWITHAES128CBCSHA, TLSRSAWITHAES128CBCSHA256, TLSRSAWITHAES128GCMSHA256, TLSRSAWITHAES256CBCSHA, TLSRSAWITHAES256CBCSHA256, TLSRSAWITHAES256GCMSHA384}
+}
+
+// ApplicationGatewaySslPolicyName enumerates the values for application gateway ssl policy name.
+type ApplicationGatewaySslPolicyName string
+
+const (
+ // AppGwSslPolicy20150501 ...
+ AppGwSslPolicy20150501 ApplicationGatewaySslPolicyName = "AppGwSslPolicy20150501"
+ // AppGwSslPolicy20170401 ...
+ AppGwSslPolicy20170401 ApplicationGatewaySslPolicyName = "AppGwSslPolicy20170401"
+ // AppGwSslPolicy20170401S ...
+ AppGwSslPolicy20170401S ApplicationGatewaySslPolicyName = "AppGwSslPolicy20170401S"
+)
+
+// PossibleApplicationGatewaySslPolicyNameValues returns an array of possible values for the ApplicationGatewaySslPolicyName const type.
+func PossibleApplicationGatewaySslPolicyNameValues() []ApplicationGatewaySslPolicyName {
+ return []ApplicationGatewaySslPolicyName{AppGwSslPolicy20150501, AppGwSslPolicy20170401, AppGwSslPolicy20170401S}
+}
+
+// ApplicationGatewaySslPolicyType enumerates the values for application gateway ssl policy type.
+type ApplicationGatewaySslPolicyType string
+
+const (
+ // Custom ...
+ Custom ApplicationGatewaySslPolicyType = "Custom"
+ // Predefined ...
+ Predefined ApplicationGatewaySslPolicyType = "Predefined"
+)
+
+// PossibleApplicationGatewaySslPolicyTypeValues returns an array of possible values for the ApplicationGatewaySslPolicyType const type.
+func PossibleApplicationGatewaySslPolicyTypeValues() []ApplicationGatewaySslPolicyType {
+ return []ApplicationGatewaySslPolicyType{Custom, Predefined}
+}
+
+// ApplicationGatewaySslProtocol enumerates the values for application gateway ssl protocol.
+type ApplicationGatewaySslProtocol string
+
+const (
+ // TLSv10 ...
+ TLSv10 ApplicationGatewaySslProtocol = "TLSv1_0"
+ // TLSv11 ...
+ TLSv11 ApplicationGatewaySslProtocol = "TLSv1_1"
+ // TLSv12 ...
+ TLSv12 ApplicationGatewaySslProtocol = "TLSv1_2"
+)
+
+// PossibleApplicationGatewaySslProtocolValues returns an array of possible values for the ApplicationGatewaySslProtocol const type.
+func PossibleApplicationGatewaySslProtocolValues() []ApplicationGatewaySslProtocol {
+ return []ApplicationGatewaySslProtocol{TLSv10, TLSv11, TLSv12}
+}
+
+// ApplicationGatewayTier enumerates the values for application gateway tier.
+type ApplicationGatewayTier string
+
+const (
+ // Standard ...
+ Standard ApplicationGatewayTier = "Standard"
+ // WAF ...
+ WAF ApplicationGatewayTier = "WAF"
+)
+
+// PossibleApplicationGatewayTierValues returns an array of possible values for the ApplicationGatewayTier const type.
+func PossibleApplicationGatewayTierValues() []ApplicationGatewayTier {
+ return []ApplicationGatewayTier{Standard, WAF}
+}
+
+// AssociationType enumerates the values for association type.
+type AssociationType string
+
+const (
+ // Associated ...
+ Associated AssociationType = "Associated"
+ // Contains ...
+ Contains AssociationType = "Contains"
+)
+
+// PossibleAssociationTypeValues returns an array of possible values for the AssociationType const type.
+func PossibleAssociationTypeValues() []AssociationType {
+ return []AssociationType{Associated, Contains}
+}
+
+// AuthenticationMethod enumerates the values for authentication method.
+type AuthenticationMethod string
+
+const (
+ // EAPMSCHAPv2 ...
+ EAPMSCHAPv2 AuthenticationMethod = "EAPMSCHAPv2"
+ // EAPTLS ...
+ EAPTLS AuthenticationMethod = "EAPTLS"
+)
+
+// PossibleAuthenticationMethodValues returns an array of possible values for the AuthenticationMethod const type.
+func PossibleAuthenticationMethodValues() []AuthenticationMethod {
+ return []AuthenticationMethod{EAPMSCHAPv2, EAPTLS}
+}
+
+// AuthorizationUseStatus enumerates the values for authorization use status.
+type AuthorizationUseStatus string
+
+const (
+ // Available ...
+ Available AuthorizationUseStatus = "Available"
+ // InUse ...
+ InUse AuthorizationUseStatus = "InUse"
+)
+
+// PossibleAuthorizationUseStatusValues returns an array of possible values for the AuthorizationUseStatus const type.
+func PossibleAuthorizationUseStatusValues() []AuthorizationUseStatus {
+ return []AuthorizationUseStatus{Available, InUse}
+}
+
+// BgpPeerState enumerates the values for bgp peer state.
+type BgpPeerState string
+
+const (
+ // BgpPeerStateConnected ...
+ BgpPeerStateConnected BgpPeerState = "Connected"
+ // BgpPeerStateConnecting ...
+ BgpPeerStateConnecting BgpPeerState = "Connecting"
+ // BgpPeerStateIdle ...
+ BgpPeerStateIdle BgpPeerState = "Idle"
+ // BgpPeerStateStopped ...
+ BgpPeerStateStopped BgpPeerState = "Stopped"
+ // BgpPeerStateUnknown ...
+ BgpPeerStateUnknown BgpPeerState = "Unknown"
+)
+
+// PossibleBgpPeerStateValues returns an array of possible values for the BgpPeerState const type.
+func PossibleBgpPeerStateValues() []BgpPeerState {
+ return []BgpPeerState{BgpPeerStateConnected, BgpPeerStateConnecting, BgpPeerStateIdle, BgpPeerStateStopped, BgpPeerStateUnknown}
+}
+
+// ConnectionState enumerates the values for connection state.
+type ConnectionState string
+
+const (
+ // ConnectionStateReachable ...
+ ConnectionStateReachable ConnectionState = "Reachable"
+ // ConnectionStateUnknown ...
+ ConnectionStateUnknown ConnectionState = "Unknown"
+ // ConnectionStateUnreachable ...
+ ConnectionStateUnreachable ConnectionState = "Unreachable"
+)
+
+// PossibleConnectionStateValues returns an array of possible values for the ConnectionState const type.
+func PossibleConnectionStateValues() []ConnectionState {
+ return []ConnectionState{ConnectionStateReachable, ConnectionStateUnknown, ConnectionStateUnreachable}
+}
+
+// ConnectionStatus enumerates the values for connection status.
+type ConnectionStatus string
+
+const (
+ // ConnectionStatusConnected ...
+ ConnectionStatusConnected ConnectionStatus = "Connected"
+ // ConnectionStatusDegraded ...
+ ConnectionStatusDegraded ConnectionStatus = "Degraded"
+ // ConnectionStatusDisconnected ...
+ ConnectionStatusDisconnected ConnectionStatus = "Disconnected"
+ // ConnectionStatusUnknown ...
+ ConnectionStatusUnknown ConnectionStatus = "Unknown"
+)
+
+// PossibleConnectionStatusValues returns an array of possible values for the ConnectionStatus const type.
+func PossibleConnectionStatusValues() []ConnectionStatus {
+ return []ConnectionStatus{ConnectionStatusConnected, ConnectionStatusDegraded, ConnectionStatusDisconnected, ConnectionStatusUnknown}
+}
+
+// DhGroup enumerates the values for dh group.
+type DhGroup string
+
+const (
+ // DHGroup1 ...
+ DHGroup1 DhGroup = "DHGroup1"
+ // DHGroup14 ...
+ DHGroup14 DhGroup = "DHGroup14"
+ // DHGroup2 ...
+ DHGroup2 DhGroup = "DHGroup2"
+ // DHGroup2048 ...
+ DHGroup2048 DhGroup = "DHGroup2048"
+ // DHGroup24 ...
+ DHGroup24 DhGroup = "DHGroup24"
+ // ECP256 ...
+ ECP256 DhGroup = "ECP256"
+ // ECP384 ...
+ ECP384 DhGroup = "ECP384"
+ // None ...
+ None DhGroup = "None"
+)
+
+// PossibleDhGroupValues returns an array of possible values for the DhGroup const type.
+func PossibleDhGroupValues() []DhGroup {
+ return []DhGroup{DHGroup1, DHGroup14, DHGroup2, DHGroup2048, DHGroup24, ECP256, ECP384, None}
+}
+
+// Direction enumerates the values for direction.
+type Direction string
+
+const (
+ // Inbound ...
+ Inbound Direction = "Inbound"
+ // Outbound ...
+ Outbound Direction = "Outbound"
+)
+
+// PossibleDirectionValues returns an array of possible values for the Direction const type.
+func PossibleDirectionValues() []Direction {
+ return []Direction{Inbound, Outbound}
+}
+
+// EffectiveRouteSource enumerates the values for effective route source.
+type EffectiveRouteSource string
+
+const (
+ // EffectiveRouteSourceDefault ...
+ EffectiveRouteSourceDefault EffectiveRouteSource = "Default"
+ // EffectiveRouteSourceUnknown ...
+ EffectiveRouteSourceUnknown EffectiveRouteSource = "Unknown"
+ // EffectiveRouteSourceUser ...
+ EffectiveRouteSourceUser EffectiveRouteSource = "User"
+ // EffectiveRouteSourceVirtualNetworkGateway ...
+ EffectiveRouteSourceVirtualNetworkGateway EffectiveRouteSource = "VirtualNetworkGateway"
+)
+
+// PossibleEffectiveRouteSourceValues returns an array of possible values for the EffectiveRouteSource const type.
+func PossibleEffectiveRouteSourceValues() []EffectiveRouteSource {
+ return []EffectiveRouteSource{EffectiveRouteSourceDefault, EffectiveRouteSourceUnknown, EffectiveRouteSourceUser, EffectiveRouteSourceVirtualNetworkGateway}
+}
+
+// EffectiveRouteState enumerates the values for effective route state.
+type EffectiveRouteState string
+
+const (
+ // Active ...
+ Active EffectiveRouteState = "Active"
+ // Invalid ...
+ Invalid EffectiveRouteState = "Invalid"
+)
+
+// PossibleEffectiveRouteStateValues returns an array of possible values for the EffectiveRouteState const type.
+func PossibleEffectiveRouteStateValues() []EffectiveRouteState {
+ return []EffectiveRouteState{Active, Invalid}
+}
+
+// EffectiveSecurityRuleProtocol enumerates the values for effective security rule protocol.
+type EffectiveSecurityRuleProtocol string
+
+const (
+ // All ...
+ All EffectiveSecurityRuleProtocol = "All"
+ // TCP ...
+ TCP EffectiveSecurityRuleProtocol = "Tcp"
+ // UDP ...
+ UDP EffectiveSecurityRuleProtocol = "Udp"
+)
+
+// PossibleEffectiveSecurityRuleProtocolValues returns an array of possible values for the EffectiveSecurityRuleProtocol const type.
+func PossibleEffectiveSecurityRuleProtocolValues() []EffectiveSecurityRuleProtocol {
+ return []EffectiveSecurityRuleProtocol{All, TCP, UDP}
+}
+
+// EvaluationState enumerates the values for evaluation state.
+type EvaluationState string
+
+const (
+ // Completed ...
+ Completed EvaluationState = "Completed"
+ // InProgress ...
+ InProgress EvaluationState = "InProgress"
+ // NotStarted ...
+ NotStarted EvaluationState = "NotStarted"
+)
+
+// PossibleEvaluationStateValues returns an array of possible values for the EvaluationState const type.
+func PossibleEvaluationStateValues() []EvaluationState {
+ return []EvaluationState{Completed, InProgress, NotStarted}
+}
+
+// ExpressRouteCircuitPeeringAdvertisedPublicPrefixState enumerates the values for express route circuit
+// peering advertised public prefix state.
+type ExpressRouteCircuitPeeringAdvertisedPublicPrefixState string
+
+const (
+ // Configured ...
+ Configured ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = "Configured"
+ // Configuring ...
+ Configuring ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = "Configuring"
+ // NotConfigured ...
+ NotConfigured ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = "NotConfigured"
+ // ValidationNeeded ...
+ ValidationNeeded ExpressRouteCircuitPeeringAdvertisedPublicPrefixState = "ValidationNeeded"
+)
+
+// PossibleExpressRouteCircuitPeeringAdvertisedPublicPrefixStateValues returns an array of possible values for the ExpressRouteCircuitPeeringAdvertisedPublicPrefixState const type.
+func PossibleExpressRouteCircuitPeeringAdvertisedPublicPrefixStateValues() []ExpressRouteCircuitPeeringAdvertisedPublicPrefixState {
+ return []ExpressRouteCircuitPeeringAdvertisedPublicPrefixState{Configured, Configuring, NotConfigured, ValidationNeeded}
+}
+
+// ExpressRouteCircuitPeeringState enumerates the values for express route circuit peering state.
+type ExpressRouteCircuitPeeringState string
+
+const (
+ // ExpressRouteCircuitPeeringStateDisabled ...
+ ExpressRouteCircuitPeeringStateDisabled ExpressRouteCircuitPeeringState = "Disabled"
+ // ExpressRouteCircuitPeeringStateEnabled ...
+ ExpressRouteCircuitPeeringStateEnabled ExpressRouteCircuitPeeringState = "Enabled"
+)
+
+// PossibleExpressRouteCircuitPeeringStateValues returns an array of possible values for the ExpressRouteCircuitPeeringState const type.
+func PossibleExpressRouteCircuitPeeringStateValues() []ExpressRouteCircuitPeeringState {
+ return []ExpressRouteCircuitPeeringState{ExpressRouteCircuitPeeringStateDisabled, ExpressRouteCircuitPeeringStateEnabled}
+}
+
+// ExpressRouteCircuitPeeringType enumerates the values for express route circuit peering type.
+type ExpressRouteCircuitPeeringType string
+
+const (
+ // AzurePrivatePeering ...
+ AzurePrivatePeering ExpressRouteCircuitPeeringType = "AzurePrivatePeering"
+ // AzurePublicPeering ...
+ AzurePublicPeering ExpressRouteCircuitPeeringType = "AzurePublicPeering"
+ // MicrosoftPeering ...
+ MicrosoftPeering ExpressRouteCircuitPeeringType = "MicrosoftPeering"
+)
+
+// PossibleExpressRouteCircuitPeeringTypeValues returns an array of possible values for the ExpressRouteCircuitPeeringType const type.
+func PossibleExpressRouteCircuitPeeringTypeValues() []ExpressRouteCircuitPeeringType {
+ return []ExpressRouteCircuitPeeringType{AzurePrivatePeering, AzurePublicPeering, MicrosoftPeering}
+}
+
+// ExpressRouteCircuitSkuFamily enumerates the values for express route circuit sku family.
+type ExpressRouteCircuitSkuFamily string
+
+const (
+ // MeteredData ...
+ MeteredData ExpressRouteCircuitSkuFamily = "MeteredData"
+ // UnlimitedData ...
+ UnlimitedData ExpressRouteCircuitSkuFamily = "UnlimitedData"
+)
+
+// PossibleExpressRouteCircuitSkuFamilyValues returns an array of possible values for the ExpressRouteCircuitSkuFamily const type.
+func PossibleExpressRouteCircuitSkuFamilyValues() []ExpressRouteCircuitSkuFamily {
+ return []ExpressRouteCircuitSkuFamily{MeteredData, UnlimitedData}
+}
+
+// ExpressRouteCircuitSkuTier enumerates the values for express route circuit sku tier.
+type ExpressRouteCircuitSkuTier string
+
+const (
+ // ExpressRouteCircuitSkuTierPremium ...
+ ExpressRouteCircuitSkuTierPremium ExpressRouteCircuitSkuTier = "Premium"
+ // ExpressRouteCircuitSkuTierStandard ...
+ ExpressRouteCircuitSkuTierStandard ExpressRouteCircuitSkuTier = "Standard"
+)
+
+// PossibleExpressRouteCircuitSkuTierValues returns an array of possible values for the ExpressRouteCircuitSkuTier const type.
+func PossibleExpressRouteCircuitSkuTierValues() []ExpressRouteCircuitSkuTier {
+ return []ExpressRouteCircuitSkuTier{ExpressRouteCircuitSkuTierPremium, ExpressRouteCircuitSkuTierStandard}
+}
+
+// IkeEncryption enumerates the values for ike encryption.
+type IkeEncryption string
+
+const (
+ // AES128 ...
+ AES128 IkeEncryption = "AES128"
+ // AES192 ...
+ AES192 IkeEncryption = "AES192"
+ // AES256 ...
+ AES256 IkeEncryption = "AES256"
+ // DES ...
+ DES IkeEncryption = "DES"
+ // DES3 ...
+ DES3 IkeEncryption = "DES3"
+)
+
+// PossibleIkeEncryptionValues returns an array of possible values for the IkeEncryption const type.
+func PossibleIkeEncryptionValues() []IkeEncryption {
+ return []IkeEncryption{AES128, AES192, AES256, DES, DES3}
+}
+
+// IkeIntegrity enumerates the values for ike integrity.
+type IkeIntegrity string
+
+const (
+ // MD5 ...
+ MD5 IkeIntegrity = "MD5"
+ // SHA1 ...
+ SHA1 IkeIntegrity = "SHA1"
+ // SHA256 ...
+ SHA256 IkeIntegrity = "SHA256"
+ // SHA384 ...
+ SHA384 IkeIntegrity = "SHA384"
+)
+
+// PossibleIkeIntegrityValues returns an array of possible values for the IkeIntegrity const type.
+func PossibleIkeIntegrityValues() []IkeIntegrity {
+ return []IkeIntegrity{MD5, SHA1, SHA256, SHA384}
+}
+
+// IPAllocationMethod enumerates the values for ip allocation method.
+type IPAllocationMethod string
+
+const (
+ // Dynamic ...
+ Dynamic IPAllocationMethod = "Dynamic"
+ // Static ...
+ Static IPAllocationMethod = "Static"
+)
+
+// PossibleIPAllocationMethodValues returns an array of possible values for the IPAllocationMethod const type.
+func PossibleIPAllocationMethodValues() []IPAllocationMethod {
+ return []IPAllocationMethod{Dynamic, Static}
+}
+
+// IpsecEncryption enumerates the values for ipsec encryption.
+type IpsecEncryption string
+
+const (
+ // IpsecEncryptionAES128 ...
+ IpsecEncryptionAES128 IpsecEncryption = "AES128"
+ // IpsecEncryptionAES192 ...
+ IpsecEncryptionAES192 IpsecEncryption = "AES192"
+ // IpsecEncryptionAES256 ...
+ IpsecEncryptionAES256 IpsecEncryption = "AES256"
+ // IpsecEncryptionDES ...
+ IpsecEncryptionDES IpsecEncryption = "DES"
+ // IpsecEncryptionDES3 ...
+ IpsecEncryptionDES3 IpsecEncryption = "DES3"
+ // IpsecEncryptionGCMAES128 ...
+ IpsecEncryptionGCMAES128 IpsecEncryption = "GCMAES128"
+ // IpsecEncryptionGCMAES192 ...
+ IpsecEncryptionGCMAES192 IpsecEncryption = "GCMAES192"
+ // IpsecEncryptionGCMAES256 ...
+ IpsecEncryptionGCMAES256 IpsecEncryption = "GCMAES256"
+ // IpsecEncryptionNone ...
+ IpsecEncryptionNone IpsecEncryption = "None"
+)
+
+// PossibleIpsecEncryptionValues returns an array of possible values for the IpsecEncryption const type.
+func PossibleIpsecEncryptionValues() []IpsecEncryption {
+ return []IpsecEncryption{IpsecEncryptionAES128, IpsecEncryptionAES192, IpsecEncryptionAES256, IpsecEncryptionDES, IpsecEncryptionDES3, IpsecEncryptionGCMAES128, IpsecEncryptionGCMAES192, IpsecEncryptionGCMAES256, IpsecEncryptionNone}
+}
+
+// IpsecIntegrity enumerates the values for ipsec integrity.
+type IpsecIntegrity string
+
+const (
+ // IpsecIntegrityGCMAES128 ...
+ IpsecIntegrityGCMAES128 IpsecIntegrity = "GCMAES128"
+ // IpsecIntegrityGCMAES192 ...
+ IpsecIntegrityGCMAES192 IpsecIntegrity = "GCMAES192"
+ // IpsecIntegrityGCMAES256 ...
+ IpsecIntegrityGCMAES256 IpsecIntegrity = "GCMAES256"
+ // IpsecIntegrityMD5 ...
+ IpsecIntegrityMD5 IpsecIntegrity = "MD5"
+ // IpsecIntegritySHA1 ...
+ IpsecIntegritySHA1 IpsecIntegrity = "SHA1"
+ // IpsecIntegritySHA256 ...
+ IpsecIntegritySHA256 IpsecIntegrity = "SHA256"
+)
+
+// PossibleIpsecIntegrityValues returns an array of possible values for the IpsecIntegrity const type.
+func PossibleIpsecIntegrityValues() []IpsecIntegrity {
+ return []IpsecIntegrity{IpsecIntegrityGCMAES128, IpsecIntegrityGCMAES192, IpsecIntegrityGCMAES256, IpsecIntegrityMD5, IpsecIntegritySHA1, IpsecIntegritySHA256}
+}
+
+// IPVersion enumerates the values for ip version.
+type IPVersion string
+
+const (
+ // IPv4 ...
+ IPv4 IPVersion = "IPv4"
+ // IPv6 ...
+ IPv6 IPVersion = "IPv6"
+)
+
+// PossibleIPVersionValues returns an array of possible values for the IPVersion const type.
+func PossibleIPVersionValues() []IPVersion {
+ return []IPVersion{IPv4, IPv6}
+}
+
+// IssueType enumerates the values for issue type.
+type IssueType string
+
+const (
+ // IssueTypeAgentStopped ...
+ IssueTypeAgentStopped IssueType = "AgentStopped"
+ // IssueTypeDNSResolution ...
+ IssueTypeDNSResolution IssueType = "DnsResolution"
+ // IssueTypeGuestFirewall ...
+ IssueTypeGuestFirewall IssueType = "GuestFirewall"
+ // IssueTypeNetworkSecurityRule ...
+ IssueTypeNetworkSecurityRule IssueType = "NetworkSecurityRule"
+ // IssueTypePlatform ...
+ IssueTypePlatform IssueType = "Platform"
+ // IssueTypePortThrottled ...
+ IssueTypePortThrottled IssueType = "PortThrottled"
+ // IssueTypeSocketBind ...
+ IssueTypeSocketBind IssueType = "SocketBind"
+ // IssueTypeUnknown ...
+ IssueTypeUnknown IssueType = "Unknown"
+ // IssueTypeUserDefinedRoute ...
+ IssueTypeUserDefinedRoute IssueType = "UserDefinedRoute"
+)
+
+// PossibleIssueTypeValues returns an array of possible values for the IssueType const type.
+func PossibleIssueTypeValues() []IssueType {
+ return []IssueType{IssueTypeAgentStopped, IssueTypeDNSResolution, IssueTypeGuestFirewall, IssueTypeNetworkSecurityRule, IssueTypePlatform, IssueTypePortThrottled, IssueTypeSocketBind, IssueTypeUnknown, IssueTypeUserDefinedRoute}
+}
+
+// LoadBalancerSkuName enumerates the values for load balancer sku name.
+type LoadBalancerSkuName string
+
+const (
+ // LoadBalancerSkuNameBasic ...
+ LoadBalancerSkuNameBasic LoadBalancerSkuName = "Basic"
+ // LoadBalancerSkuNameStandard ...
+ LoadBalancerSkuNameStandard LoadBalancerSkuName = "Standard"
+)
+
+// PossibleLoadBalancerSkuNameValues returns an array of possible values for the LoadBalancerSkuName const type.
+func PossibleLoadBalancerSkuNameValues() []LoadBalancerSkuName {
+ return []LoadBalancerSkuName{LoadBalancerSkuNameBasic, LoadBalancerSkuNameStandard}
+}
+
+// LoadDistribution enumerates the values for load distribution.
+type LoadDistribution string
+
+const (
+ // Default ...
+ Default LoadDistribution = "Default"
+ // SourceIP ...
+ SourceIP LoadDistribution = "SourceIP"
+ // SourceIPProtocol ...
+ SourceIPProtocol LoadDistribution = "SourceIPProtocol"
+)
+
+// PossibleLoadDistributionValues returns an array of possible values for the LoadDistribution const type.
+func PossibleLoadDistributionValues() []LoadDistribution {
+ return []LoadDistribution{Default, SourceIP, SourceIPProtocol}
+}
+
+// NextHopType enumerates the values for next hop type.
+type NextHopType string
+
+const (
+ // NextHopTypeHyperNetGateway ...
+ NextHopTypeHyperNetGateway NextHopType = "HyperNetGateway"
+ // NextHopTypeInternet ...
+ NextHopTypeInternet NextHopType = "Internet"
+ // NextHopTypeNone ...
+ NextHopTypeNone NextHopType = "None"
+ // NextHopTypeVirtualAppliance ...
+ NextHopTypeVirtualAppliance NextHopType = "VirtualAppliance"
+ // NextHopTypeVirtualNetworkGateway ...
+ NextHopTypeVirtualNetworkGateway NextHopType = "VirtualNetworkGateway"
+ // NextHopTypeVnetLocal ...
+ NextHopTypeVnetLocal NextHopType = "VnetLocal"
+)
+
+// PossibleNextHopTypeValues returns an array of possible values for the NextHopType const type.
+func PossibleNextHopTypeValues() []NextHopType {
+ return []NextHopType{NextHopTypeHyperNetGateway, NextHopTypeInternet, NextHopTypeNone, NextHopTypeVirtualAppliance, NextHopTypeVirtualNetworkGateway, NextHopTypeVnetLocal}
+}
+
+// OperationStatus enumerates the values for operation status.
+type OperationStatus string
+
+const (
+ // OperationStatusFailed ...
+ OperationStatusFailed OperationStatus = "Failed"
+ // OperationStatusInProgress ...
+ OperationStatusInProgress OperationStatus = "InProgress"
+ // OperationStatusSucceeded ...
+ OperationStatusSucceeded OperationStatus = "Succeeded"
+)
+
+// PossibleOperationStatusValues returns an array of possible values for the OperationStatus const type.
+func PossibleOperationStatusValues() []OperationStatus {
+ return []OperationStatus{OperationStatusFailed, OperationStatusInProgress, OperationStatusSucceeded}
+}
+
+// Origin enumerates the values for origin.
+type Origin string
+
+const (
+ // OriginInbound ...
+ OriginInbound Origin = "Inbound"
+ // OriginLocal ...
+ OriginLocal Origin = "Local"
+ // OriginOutbound ...
+ OriginOutbound Origin = "Outbound"
+)
+
+// PossibleOriginValues returns an array of possible values for the Origin const type.
+func PossibleOriginValues() []Origin {
+ return []Origin{OriginInbound, OriginLocal, OriginOutbound}
+}
+
+// PcError enumerates the values for pc error.
+type PcError string
+
+const (
+ // AgentStopped ...
+ AgentStopped PcError = "AgentStopped"
+ // CaptureFailed ...
+ CaptureFailed PcError = "CaptureFailed"
+ // InternalError ...
+ InternalError PcError = "InternalError"
+ // LocalFileFailed ...
+ LocalFileFailed PcError = "LocalFileFailed"
+ // StorageFailed ...
+ StorageFailed PcError = "StorageFailed"
+)
+
+// PossiblePcErrorValues returns an array of possible values for the PcError const type.
+func PossiblePcErrorValues() []PcError {
+ return []PcError{AgentStopped, CaptureFailed, InternalError, LocalFileFailed, StorageFailed}
+}
+
+// PcProtocol enumerates the values for pc protocol.
+type PcProtocol string
+
+const (
+ // PcProtocolAny ...
+ PcProtocolAny PcProtocol = "Any"
+ // PcProtocolTCP ...
+ PcProtocolTCP PcProtocol = "TCP"
+ // PcProtocolUDP ...
+ PcProtocolUDP PcProtocol = "UDP"
+)
+
+// PossiblePcProtocolValues returns an array of possible values for the PcProtocol const type.
+func PossiblePcProtocolValues() []PcProtocol {
+ return []PcProtocol{PcProtocolAny, PcProtocolTCP, PcProtocolUDP}
+}
+
+// PcStatus enumerates the values for pc status.
+type PcStatus string
+
+const (
+ // PcStatusError ...
+ PcStatusError PcStatus = "Error"
+ // PcStatusNotStarted ...
+ PcStatusNotStarted PcStatus = "NotStarted"
+ // PcStatusRunning ...
+ PcStatusRunning PcStatus = "Running"
+ // PcStatusStopped ...
+ PcStatusStopped PcStatus = "Stopped"
+ // PcStatusUnknown ...
+ PcStatusUnknown PcStatus = "Unknown"
+)
+
+// PossiblePcStatusValues returns an array of possible values for the PcStatus const type.
+func PossiblePcStatusValues() []PcStatus {
+ return []PcStatus{PcStatusError, PcStatusNotStarted, PcStatusRunning, PcStatusStopped, PcStatusUnknown}
+}
+
+// PfsGroup enumerates the values for pfs group.
+type PfsGroup string
+
+const (
+ // PfsGroupECP256 ...
+ PfsGroupECP256 PfsGroup = "ECP256"
+ // PfsGroupECP384 ...
+ PfsGroupECP384 PfsGroup = "ECP384"
+ // PfsGroupNone ...
+ PfsGroupNone PfsGroup = "None"
+ // PfsGroupPFS1 ...
+ PfsGroupPFS1 PfsGroup = "PFS1"
+ // PfsGroupPFS2 ...
+ PfsGroupPFS2 PfsGroup = "PFS2"
+ // PfsGroupPFS2048 ...
+ PfsGroupPFS2048 PfsGroup = "PFS2048"
+ // PfsGroupPFS24 ...
+ PfsGroupPFS24 PfsGroup = "PFS24"
+)
+
+// PossiblePfsGroupValues returns an array of possible values for the PfsGroup const type.
+func PossiblePfsGroupValues() []PfsGroup {
+ return []PfsGroup{PfsGroupECP256, PfsGroupECP384, PfsGroupNone, PfsGroupPFS1, PfsGroupPFS2, PfsGroupPFS2048, PfsGroupPFS24}
+}
+
+// ProbeProtocol enumerates the values for probe protocol.
+type ProbeProtocol string
+
+const (
+ // ProbeProtocolHTTP ...
+ ProbeProtocolHTTP ProbeProtocol = "Http"
+ // ProbeProtocolTCP ...
+ ProbeProtocolTCP ProbeProtocol = "Tcp"
+)
+
+// PossibleProbeProtocolValues returns an array of possible values for the ProbeProtocol const type.
+func PossibleProbeProtocolValues() []ProbeProtocol {
+ return []ProbeProtocol{ProbeProtocolHTTP, ProbeProtocolTCP}
+}
+
+// ProcessorArchitecture enumerates the values for processor architecture.
+type ProcessorArchitecture string
+
+const (
+ // Amd64 ...
+ Amd64 ProcessorArchitecture = "Amd64"
+ // X86 ...
+ X86 ProcessorArchitecture = "X86"
+)
+
+// PossibleProcessorArchitectureValues returns an array of possible values for the ProcessorArchitecture const type.
+func PossibleProcessorArchitectureValues() []ProcessorArchitecture {
+ return []ProcessorArchitecture{Amd64, X86}
+}
+
+// Protocol enumerates the values for protocol.
+type Protocol string
+
+const (
+ // ProtocolTCP ...
+ ProtocolTCP Protocol = "TCP"
+ // ProtocolUDP ...
+ ProtocolUDP Protocol = "UDP"
+)
+
+// PossibleProtocolValues returns an array of possible values for the Protocol const type.
+func PossibleProtocolValues() []Protocol {
+ return []Protocol{ProtocolTCP, ProtocolUDP}
+}
+
+// ProvisioningState enumerates the values for provisioning state.
+type ProvisioningState string
+
+const (
+ // Deleting ...
+ Deleting ProvisioningState = "Deleting"
+ // Failed ...
+ Failed ProvisioningState = "Failed"
+ // Succeeded ...
+ Succeeded ProvisioningState = "Succeeded"
+ // Updating ...
+ Updating ProvisioningState = "Updating"
+)
+
+// PossibleProvisioningStateValues returns an array of possible values for the ProvisioningState const type.
+func PossibleProvisioningStateValues() []ProvisioningState {
+ return []ProvisioningState{Deleting, Failed, Succeeded, Updating}
+}
+
+// PublicIPAddressSkuName enumerates the values for public ip address sku name.
+type PublicIPAddressSkuName string
+
+const (
+ // PublicIPAddressSkuNameBasic ...
+ PublicIPAddressSkuNameBasic PublicIPAddressSkuName = "Basic"
+ // PublicIPAddressSkuNameStandard ...
+ PublicIPAddressSkuNameStandard PublicIPAddressSkuName = "Standard"
+)
+
+// PossiblePublicIPAddressSkuNameValues returns an array of possible values for the PublicIPAddressSkuName const type.
+func PossiblePublicIPAddressSkuNameValues() []PublicIPAddressSkuName {
+ return []PublicIPAddressSkuName{PublicIPAddressSkuNameBasic, PublicIPAddressSkuNameStandard}
+}
+
+// RouteNextHopType enumerates the values for route next hop type.
+type RouteNextHopType string
+
+const (
+ // RouteNextHopTypeInternet ...
+ RouteNextHopTypeInternet RouteNextHopType = "Internet"
+ // RouteNextHopTypeNone ...
+ RouteNextHopTypeNone RouteNextHopType = "None"
+ // RouteNextHopTypeVirtualAppliance ...
+ RouteNextHopTypeVirtualAppliance RouteNextHopType = "VirtualAppliance"
+ // RouteNextHopTypeVirtualNetworkGateway ...
+ RouteNextHopTypeVirtualNetworkGateway RouteNextHopType = "VirtualNetworkGateway"
+ // RouteNextHopTypeVnetLocal ...
+ RouteNextHopTypeVnetLocal RouteNextHopType = "VnetLocal"
+)
+
+// PossibleRouteNextHopTypeValues returns an array of possible values for the RouteNextHopType const type.
+func PossibleRouteNextHopTypeValues() []RouteNextHopType {
+ return []RouteNextHopType{RouteNextHopTypeInternet, RouteNextHopTypeNone, RouteNextHopTypeVirtualAppliance, RouteNextHopTypeVirtualNetworkGateway, RouteNextHopTypeVnetLocal}
+}
+
+// SecurityRuleAccess enumerates the values for security rule access.
+type SecurityRuleAccess string
+
+const (
+ // SecurityRuleAccessAllow ...
+ SecurityRuleAccessAllow SecurityRuleAccess = "Allow"
+ // SecurityRuleAccessDeny ...
+ SecurityRuleAccessDeny SecurityRuleAccess = "Deny"
+)
+
+// PossibleSecurityRuleAccessValues returns an array of possible values for the SecurityRuleAccess const type.
+func PossibleSecurityRuleAccessValues() []SecurityRuleAccess {
+ return []SecurityRuleAccess{SecurityRuleAccessAllow, SecurityRuleAccessDeny}
+}
+
+// SecurityRuleDirection enumerates the values for security rule direction.
+type SecurityRuleDirection string
+
+const (
+ // SecurityRuleDirectionInbound ...
+ SecurityRuleDirectionInbound SecurityRuleDirection = "Inbound"
+ // SecurityRuleDirectionOutbound ...
+ SecurityRuleDirectionOutbound SecurityRuleDirection = "Outbound"
+)
+
+// PossibleSecurityRuleDirectionValues returns an array of possible values for the SecurityRuleDirection const type.
+func PossibleSecurityRuleDirectionValues() []SecurityRuleDirection {
+ return []SecurityRuleDirection{SecurityRuleDirectionInbound, SecurityRuleDirectionOutbound}
+}
+
+// SecurityRuleProtocol enumerates the values for security rule protocol.
+type SecurityRuleProtocol string
+
+const (
+ // SecurityRuleProtocolAsterisk ...
+ SecurityRuleProtocolAsterisk SecurityRuleProtocol = "*"
+ // SecurityRuleProtocolTCP ...
+ SecurityRuleProtocolTCP SecurityRuleProtocol = "Tcp"
+ // SecurityRuleProtocolUDP ...
+ SecurityRuleProtocolUDP SecurityRuleProtocol = "Udp"
+)
+
+// PossibleSecurityRuleProtocolValues returns an array of possible values for the SecurityRuleProtocol const type.
+func PossibleSecurityRuleProtocolValues() []SecurityRuleProtocol {
+ return []SecurityRuleProtocol{SecurityRuleProtocolAsterisk, SecurityRuleProtocolTCP, SecurityRuleProtocolUDP}
+}
+
+// ServiceProviderProvisioningState enumerates the values for service provider provisioning state.
+type ServiceProviderProvisioningState string
+
+const (
+ // Deprovisioning ...
+ Deprovisioning ServiceProviderProvisioningState = "Deprovisioning"
+ // NotProvisioned ...
+ NotProvisioned ServiceProviderProvisioningState = "NotProvisioned"
+ // Provisioned ...
+ Provisioned ServiceProviderProvisioningState = "Provisioned"
+ // Provisioning ...
+ Provisioning ServiceProviderProvisioningState = "Provisioning"
+)
+
+// PossibleServiceProviderProvisioningStateValues returns an array of possible values for the ServiceProviderProvisioningState const type.
+func PossibleServiceProviderProvisioningStateValues() []ServiceProviderProvisioningState {
+ return []ServiceProviderProvisioningState{Deprovisioning, NotProvisioned, Provisioned, Provisioning}
+}
+
+// Severity enumerates the values for severity.
+type Severity string
+
+const (
+ // SeverityError ...
+ SeverityError Severity = "Error"
+ // SeverityWarning ...
+ SeverityWarning Severity = "Warning"
+)
+
+// PossibleSeverityValues returns an array of possible values for the Severity const type.
+func PossibleSeverityValues() []Severity {
+ return []Severity{SeverityError, SeverityWarning}
+}
+
+// TransportProtocol enumerates the values for transport protocol.
+type TransportProtocol string
+
+const (
+ // TransportProtocolAll ...
+ TransportProtocolAll TransportProtocol = "All"
+ // TransportProtocolTCP ...
+ TransportProtocolTCP TransportProtocol = "Tcp"
+ // TransportProtocolUDP ...
+ TransportProtocolUDP TransportProtocol = "Udp"
+)
+
+// PossibleTransportProtocolValues returns an array of possible values for the TransportProtocol const type.
+func PossibleTransportProtocolValues() []TransportProtocol {
+ return []TransportProtocol{TransportProtocolAll, TransportProtocolTCP, TransportProtocolUDP}
+}
+
+// VirtualNetworkGatewayConnectionStatus enumerates the values for virtual network gateway connection status.
+type VirtualNetworkGatewayConnectionStatus string
+
+const (
+ // VirtualNetworkGatewayConnectionStatusConnected ...
+ VirtualNetworkGatewayConnectionStatusConnected VirtualNetworkGatewayConnectionStatus = "Connected"
+ // VirtualNetworkGatewayConnectionStatusConnecting ...
+ VirtualNetworkGatewayConnectionStatusConnecting VirtualNetworkGatewayConnectionStatus = "Connecting"
+ // VirtualNetworkGatewayConnectionStatusNotConnected ...
+ VirtualNetworkGatewayConnectionStatusNotConnected VirtualNetworkGatewayConnectionStatus = "NotConnected"
+ // VirtualNetworkGatewayConnectionStatusUnknown ...
+ VirtualNetworkGatewayConnectionStatusUnknown VirtualNetworkGatewayConnectionStatus = "Unknown"
+)
+
+// PossibleVirtualNetworkGatewayConnectionStatusValues returns an array of possible values for the VirtualNetworkGatewayConnectionStatus const type.
+func PossibleVirtualNetworkGatewayConnectionStatusValues() []VirtualNetworkGatewayConnectionStatus {
+ return []VirtualNetworkGatewayConnectionStatus{VirtualNetworkGatewayConnectionStatusConnected, VirtualNetworkGatewayConnectionStatusConnecting, VirtualNetworkGatewayConnectionStatusNotConnected, VirtualNetworkGatewayConnectionStatusUnknown}
+}
+
+// VirtualNetworkGatewayConnectionType enumerates the values for virtual network gateway connection type.
+type VirtualNetworkGatewayConnectionType string
+
+const (
+ // ExpressRoute ...
+ ExpressRoute VirtualNetworkGatewayConnectionType = "ExpressRoute"
+ // IPsec ...
+ IPsec VirtualNetworkGatewayConnectionType = "IPsec"
+ // Vnet2Vnet ...
+ Vnet2Vnet VirtualNetworkGatewayConnectionType = "Vnet2Vnet"
+ // VPNClient ...
+ VPNClient VirtualNetworkGatewayConnectionType = "VPNClient"
+)
+
+// PossibleVirtualNetworkGatewayConnectionTypeValues returns an array of possible values for the VirtualNetworkGatewayConnectionType const type.
+func PossibleVirtualNetworkGatewayConnectionTypeValues() []VirtualNetworkGatewayConnectionType {
+ return []VirtualNetworkGatewayConnectionType{ExpressRoute, IPsec, Vnet2Vnet, VPNClient}
+}
+
+// VirtualNetworkGatewaySkuName enumerates the values for virtual network gateway sku name.
+type VirtualNetworkGatewaySkuName string
+
+const (
+ // VirtualNetworkGatewaySkuNameBasic ...
+ VirtualNetworkGatewaySkuNameBasic VirtualNetworkGatewaySkuName = "Basic"
+ // VirtualNetworkGatewaySkuNameHighPerformance ...
+ VirtualNetworkGatewaySkuNameHighPerformance VirtualNetworkGatewaySkuName = "HighPerformance"
+ // VirtualNetworkGatewaySkuNameStandard ...
+ VirtualNetworkGatewaySkuNameStandard VirtualNetworkGatewaySkuName = "Standard"
+ // VirtualNetworkGatewaySkuNameUltraPerformance ...
+ VirtualNetworkGatewaySkuNameUltraPerformance VirtualNetworkGatewaySkuName = "UltraPerformance"
+ // VirtualNetworkGatewaySkuNameVpnGw1 ...
+ VirtualNetworkGatewaySkuNameVpnGw1 VirtualNetworkGatewaySkuName = "VpnGw1"
+ // VirtualNetworkGatewaySkuNameVpnGw2 ...
+ VirtualNetworkGatewaySkuNameVpnGw2 VirtualNetworkGatewaySkuName = "VpnGw2"
+ // VirtualNetworkGatewaySkuNameVpnGw3 ...
+ VirtualNetworkGatewaySkuNameVpnGw3 VirtualNetworkGatewaySkuName = "VpnGw3"
+)
+
+// PossibleVirtualNetworkGatewaySkuNameValues returns an array of possible values for the VirtualNetworkGatewaySkuName const type.
+func PossibleVirtualNetworkGatewaySkuNameValues() []VirtualNetworkGatewaySkuName {
+ return []VirtualNetworkGatewaySkuName{VirtualNetworkGatewaySkuNameBasic, VirtualNetworkGatewaySkuNameHighPerformance, VirtualNetworkGatewaySkuNameStandard, VirtualNetworkGatewaySkuNameUltraPerformance, VirtualNetworkGatewaySkuNameVpnGw1, VirtualNetworkGatewaySkuNameVpnGw2, VirtualNetworkGatewaySkuNameVpnGw3}
+}
+
+// VirtualNetworkGatewaySkuTier enumerates the values for virtual network gateway sku tier.
+type VirtualNetworkGatewaySkuTier string
+
+const (
+ // VirtualNetworkGatewaySkuTierBasic ...
+ VirtualNetworkGatewaySkuTierBasic VirtualNetworkGatewaySkuTier = "Basic"
+ // VirtualNetworkGatewaySkuTierHighPerformance ...
+ VirtualNetworkGatewaySkuTierHighPerformance VirtualNetworkGatewaySkuTier = "HighPerformance"
+ // VirtualNetworkGatewaySkuTierStandard ...
+ VirtualNetworkGatewaySkuTierStandard VirtualNetworkGatewaySkuTier = "Standard"
+ // VirtualNetworkGatewaySkuTierUltraPerformance ...
+ VirtualNetworkGatewaySkuTierUltraPerformance VirtualNetworkGatewaySkuTier = "UltraPerformance"
+ // VirtualNetworkGatewaySkuTierVpnGw1 ...
+ VirtualNetworkGatewaySkuTierVpnGw1 VirtualNetworkGatewaySkuTier = "VpnGw1"
+ // VirtualNetworkGatewaySkuTierVpnGw2 ...
+ VirtualNetworkGatewaySkuTierVpnGw2 VirtualNetworkGatewaySkuTier = "VpnGw2"
+ // VirtualNetworkGatewaySkuTierVpnGw3 ...
+ VirtualNetworkGatewaySkuTierVpnGw3 VirtualNetworkGatewaySkuTier = "VpnGw3"
+)
+
+// PossibleVirtualNetworkGatewaySkuTierValues returns an array of possible values for the VirtualNetworkGatewaySkuTier const type.
+func PossibleVirtualNetworkGatewaySkuTierValues() []VirtualNetworkGatewaySkuTier {
+ return []VirtualNetworkGatewaySkuTier{VirtualNetworkGatewaySkuTierBasic, VirtualNetworkGatewaySkuTierHighPerformance, VirtualNetworkGatewaySkuTierStandard, VirtualNetworkGatewaySkuTierUltraPerformance, VirtualNetworkGatewaySkuTierVpnGw1, VirtualNetworkGatewaySkuTierVpnGw2, VirtualNetworkGatewaySkuTierVpnGw3}
+}
+
+// VirtualNetworkGatewayType enumerates the values for virtual network gateway type.
+type VirtualNetworkGatewayType string
+
+const (
+ // VirtualNetworkGatewayTypeExpressRoute ...
+ VirtualNetworkGatewayTypeExpressRoute VirtualNetworkGatewayType = "ExpressRoute"
+ // VirtualNetworkGatewayTypeVpn ...
+ VirtualNetworkGatewayTypeVpn VirtualNetworkGatewayType = "Vpn"
+)
+
+// PossibleVirtualNetworkGatewayTypeValues returns an array of possible values for the VirtualNetworkGatewayType const type.
+func PossibleVirtualNetworkGatewayTypeValues() []VirtualNetworkGatewayType {
+ return []VirtualNetworkGatewayType{VirtualNetworkGatewayTypeExpressRoute, VirtualNetworkGatewayTypeVpn}
+}
+
+// VirtualNetworkPeeringState enumerates the values for virtual network peering state.
+type VirtualNetworkPeeringState string
+
+const (
+ // Connected ...
+ Connected VirtualNetworkPeeringState = "Connected"
+ // Disconnected ...
+ Disconnected VirtualNetworkPeeringState = "Disconnected"
+ // Initiated ...
+ Initiated VirtualNetworkPeeringState = "Initiated"
+)
+
+// PossibleVirtualNetworkPeeringStateValues returns an array of possible values for the VirtualNetworkPeeringState const type.
+func PossibleVirtualNetworkPeeringStateValues() []VirtualNetworkPeeringState {
+ return []VirtualNetworkPeeringState{Connected, Disconnected, Initiated}
+}
+
+// VpnClientProtocol enumerates the values for vpn client protocol.
+type VpnClientProtocol string
+
+const (
+ // IkeV2 ...
+ IkeV2 VpnClientProtocol = "IkeV2"
+ // SSTP ...
+ SSTP VpnClientProtocol = "SSTP"
+)
+
+// PossibleVpnClientProtocolValues returns an array of possible values for the VpnClientProtocol const type.
+func PossibleVpnClientProtocolValues() []VpnClientProtocol {
+ return []VpnClientProtocol{IkeV2, SSTP}
+}
+
+// VpnType enumerates the values for vpn type.
+type VpnType string
+
+const (
+ // PolicyBased ...
+ PolicyBased VpnType = "PolicyBased"
+ // RouteBased ...
+ RouteBased VpnType = "RouteBased"
+)
+
+// PossibleVpnTypeValues returns an array of possible values for the VpnType const type.
+func PossibleVpnTypeValues() []VpnType {
+ return []VpnType{PolicyBased, RouteBased}
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuitauthorizations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuitauthorizations.go
new file mode 100644
index 00000000000..6cd79dd1caf
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuitauthorizations.go
@@ -0,0 +1,440 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ExpressRouteCircuitAuthorizationsClient is the network Client
+type ExpressRouteCircuitAuthorizationsClient struct {
+ BaseClient
+}
+
+// NewExpressRouteCircuitAuthorizationsClient creates an instance of the ExpressRouteCircuitAuthorizationsClient
+// client.
+func NewExpressRouteCircuitAuthorizationsClient(subscriptionID string) ExpressRouteCircuitAuthorizationsClient {
+ return NewExpressRouteCircuitAuthorizationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewExpressRouteCircuitAuthorizationsClientWithBaseURI creates an instance of the
+// ExpressRouteCircuitAuthorizationsClient client using a custom endpoint. Use this when interacting with an Azure
+// cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewExpressRouteCircuitAuthorizationsClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteCircuitAuthorizationsClient {
+ return ExpressRouteCircuitAuthorizationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates an authorization in the specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// authorizationName - the name of the authorization.
+// authorizationParameters - parameters supplied to the create or update express route circuit authorization
+// operation.
+func (client ExpressRouteCircuitAuthorizationsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, circuitName string, authorizationName string, authorizationParameters ExpressRouteCircuitAuthorization) (result ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitAuthorizationsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, circuitName, authorizationName, authorizationParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client ExpressRouteCircuitAuthorizationsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, circuitName string, authorizationName string, authorizationParameters ExpressRouteCircuitAuthorization) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationName": autorest.Encode("path", authorizationName),
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ authorizationParameters.Etag = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/authorizations/{authorizationName}", pathParameters),
+ autorest.WithJSON(authorizationParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitAuthorizationsClient) CreateOrUpdateSender(req *http.Request) (future ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitAuthorizationsClient) (erca ExpressRouteCircuitAuthorization, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ erca.Response.Response, err = future.GetResult(sender)
+ if erca.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && erca.Response.Response.StatusCode != http.StatusNoContent {
+ erca, err = client.CreateOrUpdateResponder(erca.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture", "Result", erca.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitAuthorizationsClient) CreateOrUpdateResponder(resp *http.Response) (result ExpressRouteCircuitAuthorization, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified authorization from the specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// authorizationName - the name of the authorization.
+func (client ExpressRouteCircuitAuthorizationsClient) Delete(ctx context.Context, resourceGroupName string, circuitName string, authorizationName string) (result ExpressRouteCircuitAuthorizationsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitAuthorizationsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, circuitName, authorizationName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client ExpressRouteCircuitAuthorizationsClient) DeletePreparer(ctx context.Context, resourceGroupName string, circuitName string, authorizationName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationName": autorest.Encode("path", authorizationName),
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/authorizations/{authorizationName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitAuthorizationsClient) DeleteSender(req *http.Request) (future ExpressRouteCircuitAuthorizationsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitAuthorizationsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitAuthorizationsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitAuthorizationsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified authorization from the specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// authorizationName - the name of the authorization.
+func (client ExpressRouteCircuitAuthorizationsClient) Get(ctx context.Context, resourceGroupName string, circuitName string, authorizationName string) (result ExpressRouteCircuitAuthorization, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitAuthorizationsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, circuitName, authorizationName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client ExpressRouteCircuitAuthorizationsClient) GetPreparer(ctx context.Context, resourceGroupName string, circuitName string, authorizationName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationName": autorest.Encode("path", authorizationName),
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/authorizations/{authorizationName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitAuthorizationsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitAuthorizationsClient) GetResponder(resp *http.Response) (result ExpressRouteCircuitAuthorization, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all authorizations in an express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the circuit.
+func (client ExpressRouteCircuitAuthorizationsClient) List(ctx context.Context, resourceGroupName string, circuitName string) (result AuthorizationListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitAuthorizationsClient.List")
+ defer func() {
+ sc := -1
+ if result.alr.Response.Response != nil {
+ sc = result.alr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, circuitName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.alr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.alr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.alr.hasNextLink() && result.alr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ExpressRouteCircuitAuthorizationsClient) ListPreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/authorizations", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitAuthorizationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitAuthorizationsClient) ListResponder(resp *http.Response) (result AuthorizationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ExpressRouteCircuitAuthorizationsClient) listNextResults(ctx context.Context, lastResults AuthorizationListResult) (result AuthorizationListResult, err error) {
+ req, err := lastResults.authorizationListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitAuthorizationsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ExpressRouteCircuitAuthorizationsClient) ListComplete(ctx context.Context, resourceGroupName string, circuitName string) (result AuthorizationListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitAuthorizationsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, circuitName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuitpeerings.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuitpeerings.go
new file mode 100644
index 00000000000..4e14dc5ffe9
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuitpeerings.go
@@ -0,0 +1,450 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ExpressRouteCircuitPeeringsClient is the network Client
+type ExpressRouteCircuitPeeringsClient struct {
+ BaseClient
+}
+
+// NewExpressRouteCircuitPeeringsClient creates an instance of the ExpressRouteCircuitPeeringsClient client.
+func NewExpressRouteCircuitPeeringsClient(subscriptionID string) ExpressRouteCircuitPeeringsClient {
+ return NewExpressRouteCircuitPeeringsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewExpressRouteCircuitPeeringsClientWithBaseURI creates an instance of the ExpressRouteCircuitPeeringsClient client
+// using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
+// clouds, Azure stack).
+func NewExpressRouteCircuitPeeringsClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteCircuitPeeringsClient {
+ return ExpressRouteCircuitPeeringsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a peering in the specified express route circuits.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// peeringName - the name of the peering.
+// peeringParameters - parameters supplied to the create or update express route circuit peering operation.
+func (client ExpressRouteCircuitPeeringsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, peeringParameters ExpressRouteCircuitPeering) (result ExpressRouteCircuitPeeringsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitPeeringsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: peeringParameters,
+ Constraints: []validation.Constraint{{Target: "peeringParameters.ExpressRouteCircuitPeeringPropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "peeringParameters.ExpressRouteCircuitPeeringPropertiesFormat.PeerASN", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "peeringParameters.ExpressRouteCircuitPeeringPropertiesFormat.PeerASN", Name: validation.InclusiveMaximum, Rule: int64(4294967295), Chain: nil},
+ {Target: "peeringParameters.ExpressRouteCircuitPeeringPropertiesFormat.PeerASN", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.ExpressRouteCircuitPeeringsClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, circuitName, peeringName, peeringParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client ExpressRouteCircuitPeeringsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, peeringParameters ExpressRouteCircuitPeering) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "peeringName": autorest.Encode("path", peeringName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ peeringParameters.Etag = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}", pathParameters),
+ autorest.WithJSON(peeringParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitPeeringsClient) CreateOrUpdateSender(req *http.Request) (future ExpressRouteCircuitPeeringsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitPeeringsClient) (ercp ExpressRouteCircuitPeering, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitPeeringsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ercp.Response.Response, err = future.GetResult(sender)
+ if ercp.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ercp.Response.Response.StatusCode != http.StatusNoContent {
+ ercp, err = client.CreateOrUpdateResponder(ercp.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsCreateOrUpdateFuture", "Result", ercp.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitPeeringsClient) CreateOrUpdateResponder(resp *http.Response) (result ExpressRouteCircuitPeering, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified peering from the specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// peeringName - the name of the peering.
+func (client ExpressRouteCircuitPeeringsClient) Delete(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (result ExpressRouteCircuitPeeringsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitPeeringsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, circuitName, peeringName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client ExpressRouteCircuitPeeringsClient) DeletePreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "peeringName": autorest.Encode("path", peeringName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitPeeringsClient) DeleteSender(req *http.Request) (future ExpressRouteCircuitPeeringsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitPeeringsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitPeeringsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitPeeringsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified authorization from the specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// peeringName - the name of the peering.
+func (client ExpressRouteCircuitPeeringsClient) Get(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (result ExpressRouteCircuitPeering, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitPeeringsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, circuitName, peeringName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client ExpressRouteCircuitPeeringsClient) GetPreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "peeringName": autorest.Encode("path", peeringName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitPeeringsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitPeeringsClient) GetResponder(resp *http.Response) (result ExpressRouteCircuitPeering, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all peerings in a specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+func (client ExpressRouteCircuitPeeringsClient) List(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuitPeeringListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitPeeringsClient.List")
+ defer func() {
+ sc := -1
+ if result.ercplr.Response.Response != nil {
+ sc = result.ercplr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, circuitName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.ercplr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.ercplr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.ercplr.hasNextLink() && result.ercplr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ExpressRouteCircuitPeeringsClient) ListPreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitPeeringsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitPeeringsClient) ListResponder(resp *http.Response) (result ExpressRouteCircuitPeeringListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ExpressRouteCircuitPeeringsClient) listNextResults(ctx context.Context, lastResults ExpressRouteCircuitPeeringListResult) (result ExpressRouteCircuitPeeringListResult, err error) {
+ req, err := lastResults.expressRouteCircuitPeeringListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitPeeringsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ExpressRouteCircuitPeeringsClient) ListComplete(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuitPeeringListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitPeeringsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, circuitName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuits.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuits.go
new file mode 100644
index 00000000000..d21f0da9fc3
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressroutecircuits.go
@@ -0,0 +1,1118 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ExpressRouteCircuitsClient is the network Client
+type ExpressRouteCircuitsClient struct {
+ BaseClient
+}
+
+// NewExpressRouteCircuitsClient creates an instance of the ExpressRouteCircuitsClient client.
+func NewExpressRouteCircuitsClient(subscriptionID string) ExpressRouteCircuitsClient {
+ return NewExpressRouteCircuitsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewExpressRouteCircuitsClientWithBaseURI creates an instance of the ExpressRouteCircuitsClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewExpressRouteCircuitsClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteCircuitsClient {
+ return ExpressRouteCircuitsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates an express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the circuit.
+// parameters - parameters supplied to the create or update express route circuit operation.
+func (client ExpressRouteCircuitsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, circuitName string, parameters ExpressRouteCircuit) (result ExpressRouteCircuitsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, circuitName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client ExpressRouteCircuitsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, circuitName string, parameters ExpressRouteCircuit) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ parameters.Etag = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) CreateOrUpdateSender(req *http.Request) (future ExpressRouteCircuitsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitsClient) (erc ExpressRouteCircuit, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ erc.Response.Response, err = future.GetResult(sender)
+ if erc.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && erc.Response.Response.StatusCode != http.StatusNoContent {
+ erc, err = client.CreateOrUpdateResponder(erc.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsCreateOrUpdateFuture", "Result", erc.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) CreateOrUpdateResponder(resp *http.Response) (result ExpressRouteCircuit, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+func (client ExpressRouteCircuitsClient) Delete(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuitsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, circuitName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client ExpressRouteCircuitsClient) DeletePreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) DeleteSender(req *http.Request) (future ExpressRouteCircuitsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets information about the specified express route circuit.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of express route circuit.
+func (client ExpressRouteCircuitsClient) Get(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuit, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, circuitName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client ExpressRouteCircuitsClient) GetPreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) GetResponder(resp *http.Response) (result ExpressRouteCircuit, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetPeeringStats gets all stats from an express route circuit in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// peeringName - the name of the peering.
+func (client ExpressRouteCircuitsClient) GetPeeringStats(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (result ExpressRouteCircuitStats, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.GetPeeringStats")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPeeringStatsPreparer(ctx, resourceGroupName, circuitName, peeringName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetPeeringStats", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetPeeringStatsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetPeeringStats", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetPeeringStatsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetPeeringStats", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPeeringStatsPreparer prepares the GetPeeringStats request.
+func (client ExpressRouteCircuitsClient) GetPeeringStatsPreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "peeringName": autorest.Encode("path", peeringName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/stats", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetPeeringStatsSender sends the GetPeeringStats request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) GetPeeringStatsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetPeeringStatsResponder handles the response to the GetPeeringStats request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) GetPeeringStatsResponder(resp *http.Response) (result ExpressRouteCircuitStats, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetStats gets all the stats from an express route circuit in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+func (client ExpressRouteCircuitsClient) GetStats(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuitStats, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.GetStats")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetStatsPreparer(ctx, resourceGroupName, circuitName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetStats", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetStatsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetStats", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetStatsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetStats", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetStatsPreparer prepares the GetStats request.
+func (client ExpressRouteCircuitsClient) GetStatsPreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/stats", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetStatsSender sends the GetStats request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) GetStatsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetStatsResponder handles the response to the GetStats request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) GetStatsResponder(resp *http.Response) (result ExpressRouteCircuitStats, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the express route circuits in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client ExpressRouteCircuitsClient) List(ctx context.Context, resourceGroupName string) (result ExpressRouteCircuitListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.List")
+ defer func() {
+ sc := -1
+ if result.erclr.Response.Response != nil {
+ sc = result.erclr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.erclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.erclr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.erclr.hasNextLink() && result.erclr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ExpressRouteCircuitsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) ListResponder(resp *http.Response) (result ExpressRouteCircuitListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ExpressRouteCircuitsClient) listNextResults(ctx context.Context, lastResults ExpressRouteCircuitListResult) (result ExpressRouteCircuitListResult, err error) {
+ req, err := lastResults.expressRouteCircuitListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ExpressRouteCircuitsClient) ListComplete(ctx context.Context, resourceGroupName string) (result ExpressRouteCircuitListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all the express route circuits in a subscription.
+func (client ExpressRouteCircuitsClient) ListAll(ctx context.Context) (result ExpressRouteCircuitListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.erclr.Response.Response != nil {
+ sc = result.erclr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.erclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.erclr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.erclr.hasNextLink() && result.erclr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client ExpressRouteCircuitsClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/expressRouteCircuits", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) ListAllResponder(resp *http.Response) (result ExpressRouteCircuitListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client ExpressRouteCircuitsClient) listAllNextResults(ctx context.Context, lastResults ExpressRouteCircuitListResult) (result ExpressRouteCircuitListResult, err error) {
+ req, err := lastResults.expressRouteCircuitListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ExpressRouteCircuitsClient) ListAllComplete(ctx context.Context) (result ExpressRouteCircuitListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// ListArpTable gets the currently advertised ARP table associated with the express route circuit in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// peeringName - the name of the peering.
+// devicePath - the path of the device.
+func (client ExpressRouteCircuitsClient) ListArpTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (result ExpressRouteCircuitsListArpTableFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListArpTable")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListArpTablePreparer(ctx, resourceGroupName, circuitName, peeringName, devicePath)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListArpTable", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ListArpTableSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListArpTable", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ListArpTablePreparer prepares the ListArpTable request.
+func (client ExpressRouteCircuitsClient) ListArpTablePreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "devicePath": autorest.Encode("path", devicePath),
+ "peeringName": autorest.Encode("path", peeringName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/arpTables/{devicePath}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListArpTableSender sends the ListArpTable request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) ListArpTableSender(req *http.Request) (future ExpressRouteCircuitsListArpTableFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitsClient) (ercatlr ExpressRouteCircuitsArpTableListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListArpTableFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitsListArpTableFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ercatlr.Response.Response, err = future.GetResult(sender)
+ if ercatlr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListArpTableFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ercatlr.Response.Response.StatusCode != http.StatusNoContent {
+ ercatlr, err = client.ListArpTableResponder(ercatlr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListArpTableFuture", "Result", ercatlr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ListArpTableResponder handles the response to the ListArpTable request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) ListArpTableResponder(resp *http.Response) (result ExpressRouteCircuitsArpTableListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListRoutesTable gets the currently advertised routes table associated with the express route circuit in a resource
+// group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// peeringName - the name of the peering.
+// devicePath - the path of the device.
+func (client ExpressRouteCircuitsClient) ListRoutesTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (result ExpressRouteCircuitsListRoutesTableFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListRoutesTable")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListRoutesTablePreparer(ctx, resourceGroupName, circuitName, peeringName, devicePath)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTable", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ListRoutesTableSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTable", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ListRoutesTablePreparer prepares the ListRoutesTable request.
+func (client ExpressRouteCircuitsClient) ListRoutesTablePreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "devicePath": autorest.Encode("path", devicePath),
+ "peeringName": autorest.Encode("path", peeringName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/routeTables/{devicePath}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListRoutesTableSender sends the ListRoutesTable request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) ListRoutesTableSender(req *http.Request) (future ExpressRouteCircuitsListRoutesTableFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitsClient) (ercrtlr ExpressRouteCircuitsRoutesTableListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListRoutesTableFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitsListRoutesTableFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ercrtlr.Response.Response, err = future.GetResult(sender)
+ if ercrtlr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListRoutesTableFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ercrtlr.Response.Response.StatusCode != http.StatusNoContent {
+ ercrtlr, err = client.ListRoutesTableResponder(ercrtlr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListRoutesTableFuture", "Result", ercrtlr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ListRoutesTableResponder handles the response to the ListRoutesTable request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) ListRoutesTableResponder(resp *http.Response) (result ExpressRouteCircuitsRoutesTableListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListRoutesTableSummary gets the currently advertised routes table summary associated with the express route circuit
+// in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the express route circuit.
+// peeringName - the name of the peering.
+// devicePath - the path of the device.
+func (client ExpressRouteCircuitsClient) ListRoutesTableSummary(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (result ExpressRouteCircuitsListRoutesTableSummaryFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListRoutesTableSummary")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListRoutesTableSummaryPreparer(ctx, resourceGroupName, circuitName, peeringName, devicePath)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTableSummary", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ListRoutesTableSummarySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTableSummary", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ListRoutesTableSummaryPreparer prepares the ListRoutesTableSummary request.
+func (client ExpressRouteCircuitsClient) ListRoutesTableSummaryPreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "devicePath": autorest.Encode("path", devicePath),
+ "peeringName": autorest.Encode("path", peeringName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/routeTablesSummary/{devicePath}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListRoutesTableSummarySender sends the ListRoutesTableSummary request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) ListRoutesTableSummarySender(req *http.Request) (future ExpressRouteCircuitsListRoutesTableSummaryFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitsClient) (ercrtslr ExpressRouteCircuitsRoutesTableSummaryListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListRoutesTableSummaryFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitsListRoutesTableSummaryFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ercrtslr.Response.Response, err = future.GetResult(sender)
+ if ercrtslr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListRoutesTableSummaryFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ercrtslr.Response.Response.StatusCode != http.StatusNoContent {
+ ercrtslr, err = client.ListRoutesTableSummaryResponder(ercrtslr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsListRoutesTableSummaryFuture", "Result", ercrtslr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ListRoutesTableSummaryResponder handles the response to the ListRoutesTableSummary request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) ListRoutesTableSummaryResponder(resp *http.Response) (result ExpressRouteCircuitsRoutesTableSummaryListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateTags updates an express route circuit tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// circuitName - the name of the circuit.
+// parameters - parameters supplied to update express route circuit tags.
+func (client ExpressRouteCircuitsClient) UpdateTags(ctx context.Context, resourceGroupName string, circuitName string, parameters TagsObject) (result ExpressRouteCircuitsUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, circuitName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client ExpressRouteCircuitsClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, circuitName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "circuitName": autorest.Encode("path", circuitName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteCircuitsClient) UpdateTagsSender(req *http.Request) (future ExpressRouteCircuitsUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client ExpressRouteCircuitsClient) (erc ExpressRouteCircuit, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.ExpressRouteCircuitsUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ erc.Response.Response, err = future.GetResult(sender)
+ if erc.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && erc.Response.Response.StatusCode != http.StatusNoContent {
+ erc, err = client.UpdateTagsResponder(erc.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsUpdateTagsFuture", "Result", erc.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteCircuitsClient) UpdateTagsResponder(resp *http.Response) (result ExpressRouteCircuit, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressrouteserviceproviders.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressrouteserviceproviders.go
new file mode 100644
index 00000000000..bbdf4b23398
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/expressrouteserviceproviders.go
@@ -0,0 +1,156 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// ExpressRouteServiceProvidersClient is the network Client
+type ExpressRouteServiceProvidersClient struct {
+ BaseClient
+}
+
+// NewExpressRouteServiceProvidersClient creates an instance of the ExpressRouteServiceProvidersClient client.
+func NewExpressRouteServiceProvidersClient(subscriptionID string) ExpressRouteServiceProvidersClient {
+ return NewExpressRouteServiceProvidersClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewExpressRouteServiceProvidersClientWithBaseURI creates an instance of the ExpressRouteServiceProvidersClient
+// client using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI
+// (sovereign clouds, Azure stack).
+func NewExpressRouteServiceProvidersClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteServiceProvidersClient {
+ return ExpressRouteServiceProvidersClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List gets all the available express route service providers.
+func (client ExpressRouteServiceProvidersClient) List(ctx context.Context) (result ExpressRouteServiceProviderListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteServiceProvidersClient.List")
+ defer func() {
+ sc := -1
+ if result.ersplr.Response.Response != nil {
+ sc = result.ersplr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteServiceProvidersClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.ersplr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteServiceProvidersClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.ersplr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteServiceProvidersClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.ersplr.hasNextLink() && result.ersplr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ExpressRouteServiceProvidersClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/expressRouteServiceProviders", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ExpressRouteServiceProvidersClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ExpressRouteServiceProvidersClient) ListResponder(resp *http.Response) (result ExpressRouteServiceProviderListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ExpressRouteServiceProvidersClient) listNextResults(ctx context.Context, lastResults ExpressRouteServiceProviderListResult) (result ExpressRouteServiceProviderListResult, err error) {
+ req, err := lastResults.expressRouteServiceProviderListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteServiceProvidersClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.ExpressRouteServiceProvidersClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.ExpressRouteServiceProvidersClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ExpressRouteServiceProvidersClient) ListComplete(ctx context.Context) (result ExpressRouteServiceProviderListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteServiceProvidersClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/inboundnatrules.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/inboundnatrules.go
new file mode 100644
index 00000000000..b0fb9db42e1
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/inboundnatrules.go
@@ -0,0 +1,460 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// InboundNatRulesClient is the network Client
+type InboundNatRulesClient struct {
+ BaseClient
+}
+
+// NewInboundNatRulesClient creates an instance of the InboundNatRulesClient client.
+func NewInboundNatRulesClient(subscriptionID string) InboundNatRulesClient {
+ return NewInboundNatRulesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewInboundNatRulesClientWithBaseURI creates an instance of the InboundNatRulesClient client using a custom endpoint.
+// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewInboundNatRulesClientWithBaseURI(baseURI string, subscriptionID string) InboundNatRulesClient {
+ return InboundNatRulesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a load balancer inbound nat rule.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// inboundNatRuleName - the name of the inbound nat rule.
+// inboundNatRuleParameters - parameters supplied to the create or update inbound nat rule operation.
+func (client InboundNatRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, loadBalancerName string, inboundNatRuleName string, inboundNatRuleParameters InboundNatRule) (result InboundNatRulesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InboundNatRulesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: inboundNatRuleParameters,
+ Constraints: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat.BackendIPConfiguration", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat.BackendIPConfiguration.InterfaceIPConfigurationPropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat.BackendIPConfiguration.InterfaceIPConfigurationPropertiesFormat.PublicIPAddress", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat.BackendIPConfiguration.InterfaceIPConfigurationPropertiesFormat.PublicIPAddress.PublicIPAddressPropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat.BackendIPConfiguration.InterfaceIPConfigurationPropertiesFormat.PublicIPAddress.PublicIPAddressPropertiesFormat.IPConfiguration", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat.BackendIPConfiguration.InterfaceIPConfigurationPropertiesFormat.PublicIPAddress.PublicIPAddressPropertiesFormat.IPConfiguration.IPConfigurationPropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "inboundNatRuleParameters.InboundNatRulePropertiesFormat.BackendIPConfiguration.InterfaceIPConfigurationPropertiesFormat.PublicIPAddress.PublicIPAddressPropertiesFormat.IPConfiguration.IPConfigurationPropertiesFormat.PublicIPAddress", Name: validation.Null, Rule: false, Chain: nil}}},
+ }},
+ }},
+ }},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.InboundNatRulesClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, loadBalancerName, inboundNatRuleName, inboundNatRuleParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client InboundNatRulesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, inboundNatRuleName string, inboundNatRuleParameters InboundNatRule) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "inboundNatRuleName": autorest.Encode("path", inboundNatRuleName),
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatRules/{inboundNatRuleName}", pathParameters),
+ autorest.WithJSON(inboundNatRuleParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client InboundNatRulesClient) CreateOrUpdateSender(req *http.Request) (future InboundNatRulesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client InboundNatRulesClient) (inr InboundNatRule, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.InboundNatRulesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ inr.Response.Response, err = future.GetResult(sender)
+ if inr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && inr.Response.Response.StatusCode != http.StatusNoContent {
+ inr, err = client.CreateOrUpdateResponder(inr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesCreateOrUpdateFuture", "Result", inr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client InboundNatRulesClient) CreateOrUpdateResponder(resp *http.Response) (result InboundNatRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified load balancer inbound nat rule.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// inboundNatRuleName - the name of the inbound nat rule.
+func (client InboundNatRulesClient) Delete(ctx context.Context, resourceGroupName string, loadBalancerName string, inboundNatRuleName string) (result InboundNatRulesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InboundNatRulesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, loadBalancerName, inboundNatRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client InboundNatRulesClient) DeletePreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, inboundNatRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "inboundNatRuleName": autorest.Encode("path", inboundNatRuleName),
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatRules/{inboundNatRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client InboundNatRulesClient) DeleteSender(req *http.Request) (future InboundNatRulesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client InboundNatRulesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.InboundNatRulesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client InboundNatRulesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified load balancer inbound nat rule.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// inboundNatRuleName - the name of the inbound nat rule.
+// expand - expands referenced resources.
+func (client InboundNatRulesClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, inboundNatRuleName string, expand string) (result InboundNatRule, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InboundNatRulesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, loadBalancerName, inboundNatRuleName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client InboundNatRulesClient) GetPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, inboundNatRuleName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "inboundNatRuleName": autorest.Encode("path", inboundNatRuleName),
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatRules/{inboundNatRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client InboundNatRulesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client InboundNatRulesClient) GetResponder(resp *http.Response) (result InboundNatRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the inbound nat rules in a load balancer.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+func (client InboundNatRulesClient) List(ctx context.Context, resourceGroupName string, loadBalancerName string) (result InboundNatRuleListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InboundNatRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.inrlr.Response.Response != nil {
+ sc = result.inrlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, loadBalancerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.inrlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.inrlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.inrlr.hasNextLink() && result.inrlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client InboundNatRulesClient) ListPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client InboundNatRulesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client InboundNatRulesClient) ListResponder(resp *http.Response) (result InboundNatRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client InboundNatRulesClient) listNextResults(ctx context.Context, lastResults InboundNatRuleListResult) (result InboundNatRuleListResult, err error) {
+ req, err := lastResults.inboundNatRuleListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InboundNatRulesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InboundNatRulesClient) ListComplete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result InboundNatRuleListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InboundNatRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, loadBalancerName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfaceipconfigurations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfaceipconfigurations.go
new file mode 100644
index 00000000000..83222497b58
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfaceipconfigurations.go
@@ -0,0 +1,239 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// InterfaceIPConfigurationsClient is the network Client
+type InterfaceIPConfigurationsClient struct {
+ BaseClient
+}
+
+// NewInterfaceIPConfigurationsClient creates an instance of the InterfaceIPConfigurationsClient client.
+func NewInterfaceIPConfigurationsClient(subscriptionID string) InterfaceIPConfigurationsClient {
+ return NewInterfaceIPConfigurationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewInterfaceIPConfigurationsClientWithBaseURI creates an instance of the InterfaceIPConfigurationsClient client
+// using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
+// clouds, Azure stack).
+func NewInterfaceIPConfigurationsClientWithBaseURI(baseURI string, subscriptionID string) InterfaceIPConfigurationsClient {
+ return InterfaceIPConfigurationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets the specified network interface ip configuration.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+// IPConfigurationName - the name of the ip configuration name.
+func (client InterfaceIPConfigurationsClient) Get(ctx context.Context, resourceGroupName string, networkInterfaceName string, IPConfigurationName string) (result InterfaceIPConfiguration, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceIPConfigurationsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkInterfaceName, IPConfigurationName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client InterfaceIPConfigurationsClient) GetPreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string, IPConfigurationName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "ipConfigurationName": autorest.Encode("path", IPConfigurationName),
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}/ipConfigurations/{ipConfigurationName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfaceIPConfigurationsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client InterfaceIPConfigurationsClient) GetResponder(resp *http.Response) (result InterfaceIPConfiguration, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List get all ip configurations in a network interface
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+func (client InterfaceIPConfigurationsClient) List(ctx context.Context, resourceGroupName string, networkInterfaceName string) (result InterfaceIPConfigurationListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceIPConfigurationsClient.List")
+ defer func() {
+ sc := -1
+ if result.iiclr.Response.Response != nil {
+ sc = result.iiclr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, networkInterfaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.iiclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.iiclr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.iiclr.hasNextLink() && result.iiclr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client InterfaceIPConfigurationsClient) ListPreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}/ipConfigurations", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfaceIPConfigurationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client InterfaceIPConfigurationsClient) ListResponder(resp *http.Response) (result InterfaceIPConfigurationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client InterfaceIPConfigurationsClient) listNextResults(ctx context.Context, lastResults InterfaceIPConfigurationListResult) (result InterfaceIPConfigurationListResult, err error) {
+ req, err := lastResults.interfaceIPConfigurationListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceIPConfigurationsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InterfaceIPConfigurationsClient) ListComplete(ctx context.Context, resourceGroupName string, networkInterfaceName string) (result InterfaceIPConfigurationListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceIPConfigurationsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, networkInterfaceName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfaceloadbalancers.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfaceloadbalancers.go
new file mode 100644
index 00000000000..7ab2bc2012d
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfaceloadbalancers.go
@@ -0,0 +1,161 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// InterfaceLoadBalancersClient is the network Client
+type InterfaceLoadBalancersClient struct {
+ BaseClient
+}
+
+// NewInterfaceLoadBalancersClient creates an instance of the InterfaceLoadBalancersClient client.
+func NewInterfaceLoadBalancersClient(subscriptionID string) InterfaceLoadBalancersClient {
+ return NewInterfaceLoadBalancersClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewInterfaceLoadBalancersClientWithBaseURI creates an instance of the InterfaceLoadBalancersClient client using a
+// custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds,
+// Azure stack).
+func NewInterfaceLoadBalancersClientWithBaseURI(baseURI string, subscriptionID string) InterfaceLoadBalancersClient {
+ return InterfaceLoadBalancersClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List list all load balancers in a network interface.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+func (client InterfaceLoadBalancersClient) List(ctx context.Context, resourceGroupName string, networkInterfaceName string) (result InterfaceLoadBalancerListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceLoadBalancersClient.List")
+ defer func() {
+ sc := -1
+ if result.ilblr.Response.Response != nil {
+ sc = result.ilblr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, networkInterfaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceLoadBalancersClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.ilblr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfaceLoadBalancersClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.ilblr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceLoadBalancersClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.ilblr.hasNextLink() && result.ilblr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client InterfaceLoadBalancersClient) ListPreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}/loadBalancers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfaceLoadBalancersClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client InterfaceLoadBalancersClient) ListResponder(resp *http.Response) (result InterfaceLoadBalancerListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client InterfaceLoadBalancersClient) listNextResults(ctx context.Context, lastResults InterfaceLoadBalancerListResult) (result InterfaceLoadBalancerListResult, err error) {
+ req, err := lastResults.interfaceLoadBalancerListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InterfaceLoadBalancersClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InterfaceLoadBalancersClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfaceLoadBalancersClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InterfaceLoadBalancersClient) ListComplete(ctx context.Context, resourceGroupName string, networkInterfaceName string) (result InterfaceLoadBalancerListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceLoadBalancersClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, networkInterfaceName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfacesgroup.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfacesgroup.go
new file mode 100644
index 00000000000..ffaa3f6e349
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/interfacesgroup.go
@@ -0,0 +1,1388 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// InterfacesClient is the network Client
+type InterfacesClient struct {
+ BaseClient
+}
+
+// NewInterfacesClient creates an instance of the InterfacesClient client.
+func NewInterfacesClient(subscriptionID string) InterfacesClient {
+ return NewInterfacesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewInterfacesClientWithBaseURI creates an instance of the InterfacesClient client using a custom endpoint. Use this
+// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewInterfacesClientWithBaseURI(baseURI string, subscriptionID string) InterfacesClient {
+ return InterfacesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a network interface.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+// parameters - parameters supplied to the create or update network interface operation.
+func (client InterfacesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, networkInterfaceName string, parameters Interface) (result InterfacesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, networkInterfaceName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client InterfacesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string, parameters Interface) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) CreateOrUpdateSender(req *http.Request) (future InterfacesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client InterfacesClient) (i Interface, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.InterfacesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ i.Response.Response, err = future.GetResult(sender)
+ if i.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && i.Response.Response.StatusCode != http.StatusNoContent {
+ i, err = client.CreateOrUpdateResponder(i.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesCreateOrUpdateFuture", "Result", i.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) CreateOrUpdateResponder(resp *http.Response) (result Interface, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified network interface.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+func (client InterfacesClient) Delete(ctx context.Context, resourceGroupName string, networkInterfaceName string) (result InterfacesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, networkInterfaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client InterfacesClient) DeletePreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) DeleteSender(req *http.Request) (future InterfacesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client InterfacesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.InterfacesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets information about the specified network interface.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+// expand - expands referenced resources.
+func (client InterfacesClient) Get(ctx context.Context, resourceGroupName string, networkInterfaceName string, expand string) (result Interface, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkInterfaceName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client InterfacesClient) GetPreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) GetResponder(resp *http.Response) (result Interface, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetEffectiveRouteTable gets all route tables applied to a network interface.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+func (client InterfacesClient) GetEffectiveRouteTable(ctx context.Context, resourceGroupName string, networkInterfaceName string) (result InterfacesGetEffectiveRouteTableFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.GetEffectiveRouteTable")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetEffectiveRouteTablePreparer(ctx, resourceGroupName, networkInterfaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetEffectiveRouteTable", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetEffectiveRouteTableSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetEffectiveRouteTable", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetEffectiveRouteTablePreparer prepares the GetEffectiveRouteTable request.
+func (client InterfacesClient) GetEffectiveRouteTablePreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}/effectiveRouteTable", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetEffectiveRouteTableSender sends the GetEffectiveRouteTable request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) GetEffectiveRouteTableSender(req *http.Request) (future InterfacesGetEffectiveRouteTableFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client InterfacesClient) (erlr EffectiveRouteListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesGetEffectiveRouteTableFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.InterfacesGetEffectiveRouteTableFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ erlr.Response.Response, err = future.GetResult(sender)
+ if erlr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesGetEffectiveRouteTableFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && erlr.Response.Response.StatusCode != http.StatusNoContent {
+ erlr, err = client.GetEffectiveRouteTableResponder(erlr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesGetEffectiveRouteTableFuture", "Result", erlr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetEffectiveRouteTableResponder handles the response to the GetEffectiveRouteTable request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) GetEffectiveRouteTableResponder(resp *http.Response) (result EffectiveRouteListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVirtualMachineScaleSetIPConfiguration get the specified network interface ip configuration in a virtual machine
+// scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+// virtualmachineIndex - the virtual machine index.
+// networkInterfaceName - the name of the network interface.
+// IPConfigurationName - the name of the ip configuration.
+// expand - expands referenced resources.
+func (client InterfacesClient) GetVirtualMachineScaleSetIPConfiguration(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string, expand string) (result InterfaceIPConfiguration, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.GetVirtualMachineScaleSetIPConfiguration")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetVirtualMachineScaleSetIPConfigurationPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetVirtualMachineScaleSetIPConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVirtualMachineScaleSetIPConfigurationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetVirtualMachineScaleSetIPConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVirtualMachineScaleSetIPConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetVirtualMachineScaleSetIPConfiguration", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetVirtualMachineScaleSetIPConfigurationPreparer prepares the GetVirtualMachineScaleSetIPConfiguration request.
+func (client InterfacesClient) GetVirtualMachineScaleSetIPConfigurationPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "ipConfigurationName": autorest.Encode("path", IPConfigurationName),
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces/{networkInterfaceName}/ipConfigurations/{ipConfigurationName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetVirtualMachineScaleSetIPConfigurationSender sends the GetVirtualMachineScaleSetIPConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) GetVirtualMachineScaleSetIPConfigurationSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetVirtualMachineScaleSetIPConfigurationResponder handles the response to the GetVirtualMachineScaleSetIPConfiguration request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) GetVirtualMachineScaleSetIPConfigurationResponder(resp *http.Response) (result InterfaceIPConfiguration, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVirtualMachineScaleSetNetworkInterface get the specified network interface in a virtual machine scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+// virtualmachineIndex - the virtual machine index.
+// networkInterfaceName - the name of the network interface.
+// expand - expands referenced resources.
+func (client InterfacesClient) GetVirtualMachineScaleSetNetworkInterface(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result Interface, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.GetVirtualMachineScaleSetNetworkInterface")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetVirtualMachineScaleSetNetworkInterfacePreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetVirtualMachineScaleSetNetworkInterface", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVirtualMachineScaleSetNetworkInterfaceSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetVirtualMachineScaleSetNetworkInterface", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVirtualMachineScaleSetNetworkInterfaceResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "GetVirtualMachineScaleSetNetworkInterface", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetVirtualMachineScaleSetNetworkInterfacePreparer prepares the GetVirtualMachineScaleSetNetworkInterface request.
+func (client InterfacesClient) GetVirtualMachineScaleSetNetworkInterfacePreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces/{networkInterfaceName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetVirtualMachineScaleSetNetworkInterfaceSender sends the GetVirtualMachineScaleSetNetworkInterface request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) GetVirtualMachineScaleSetNetworkInterfaceSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetVirtualMachineScaleSetNetworkInterfaceResponder handles the response to the GetVirtualMachineScaleSetNetworkInterface request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) GetVirtualMachineScaleSetNetworkInterfaceResponder(resp *http.Response) (result Interface, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all network interfaces in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client InterfacesClient) List(ctx context.Context, resourceGroupName string) (result InterfaceListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.List")
+ defer func() {
+ sc := -1
+ if result.ilr.Response.Response != nil {
+ sc = result.ilr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.ilr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.ilr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.ilr.hasNextLink() && result.ilr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client InterfacesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) ListResponder(resp *http.Response) (result InterfaceListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client InterfacesClient) listNextResults(ctx context.Context, lastResults InterfaceListResult) (result InterfaceListResult, err error) {
+ req, err := lastResults.interfaceListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InterfacesClient) ListComplete(ctx context.Context, resourceGroupName string) (result InterfaceListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all network interfaces in a subscription.
+func (client InterfacesClient) ListAll(ctx context.Context) (result InterfaceListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.ilr.Response.Response != nil {
+ sc = result.ilr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.ilr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.ilr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.ilr.hasNextLink() && result.ilr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client InterfacesClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/networkInterfaces", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) ListAllResponder(resp *http.Response) (result InterfaceListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client InterfacesClient) listAllNextResults(ctx context.Context, lastResults InterfaceListResult) (result InterfaceListResult, err error) {
+ req, err := lastResults.interfaceListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InterfacesClient) ListAllComplete(ctx context.Context) (result InterfaceListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// ListEffectiveNetworkSecurityGroups gets all network security groups applied to a network interface.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+func (client InterfacesClient) ListEffectiveNetworkSecurityGroups(ctx context.Context, resourceGroupName string, networkInterfaceName string) (result InterfacesListEffectiveNetworkSecurityGroupsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListEffectiveNetworkSecurityGroups")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListEffectiveNetworkSecurityGroupsPreparer(ctx, resourceGroupName, networkInterfaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListEffectiveNetworkSecurityGroups", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ListEffectiveNetworkSecurityGroupsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListEffectiveNetworkSecurityGroups", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ListEffectiveNetworkSecurityGroupsPreparer prepares the ListEffectiveNetworkSecurityGroups request.
+func (client InterfacesClient) ListEffectiveNetworkSecurityGroupsPreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}/effectiveNetworkSecurityGroups", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListEffectiveNetworkSecurityGroupsSender sends the ListEffectiveNetworkSecurityGroups request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) ListEffectiveNetworkSecurityGroupsSender(req *http.Request) (future InterfacesListEffectiveNetworkSecurityGroupsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client InterfacesClient) (ensglr EffectiveNetworkSecurityGroupListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesListEffectiveNetworkSecurityGroupsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.InterfacesListEffectiveNetworkSecurityGroupsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ensglr.Response.Response, err = future.GetResult(sender)
+ if ensglr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesListEffectiveNetworkSecurityGroupsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ensglr.Response.Response.StatusCode != http.StatusNoContent {
+ ensglr, err = client.ListEffectiveNetworkSecurityGroupsResponder(ensglr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesListEffectiveNetworkSecurityGroupsFuture", "Result", ensglr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ListEffectiveNetworkSecurityGroupsResponder handles the response to the ListEffectiveNetworkSecurityGroups request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) ListEffectiveNetworkSecurityGroupsResponder(resp *http.Response) (result EffectiveNetworkSecurityGroupListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListVirtualMachineScaleSetIPConfigurations get the specified network interface ip configuration in a virtual machine
+// scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+// virtualmachineIndex - the virtual machine index.
+// networkInterfaceName - the name of the network interface.
+// expand - expands referenced resources.
+func (client InterfacesClient) ListVirtualMachineScaleSetIPConfigurations(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result InterfaceIPConfigurationListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListVirtualMachineScaleSetIPConfigurations")
+ defer func() {
+ sc := -1
+ if result.iiclr.Response.Response != nil {
+ sc = result.iiclr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listVirtualMachineScaleSetIPConfigurationsNextResults
+ req, err := client.ListVirtualMachineScaleSetIPConfigurationsPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetIPConfigurations", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVirtualMachineScaleSetIPConfigurationsSender(req)
+ if err != nil {
+ result.iiclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetIPConfigurations", resp, "Failure sending request")
+ return
+ }
+
+ result.iiclr, err = client.ListVirtualMachineScaleSetIPConfigurationsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetIPConfigurations", resp, "Failure responding to request")
+ return
+ }
+ if result.iiclr.hasNextLink() && result.iiclr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListVirtualMachineScaleSetIPConfigurationsPreparer prepares the ListVirtualMachineScaleSetIPConfigurations request.
+func (client InterfacesClient) ListVirtualMachineScaleSetIPConfigurationsPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces/{networkInterfaceName}/ipConfigurations", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListVirtualMachineScaleSetIPConfigurationsSender sends the ListVirtualMachineScaleSetIPConfigurations request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) ListVirtualMachineScaleSetIPConfigurationsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListVirtualMachineScaleSetIPConfigurationsResponder handles the response to the ListVirtualMachineScaleSetIPConfigurations request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) ListVirtualMachineScaleSetIPConfigurationsResponder(resp *http.Response) (result InterfaceIPConfigurationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listVirtualMachineScaleSetIPConfigurationsNextResults retrieves the next set of results, if any.
+func (client InterfacesClient) listVirtualMachineScaleSetIPConfigurationsNextResults(ctx context.Context, lastResults InterfaceIPConfigurationListResult) (result InterfaceIPConfigurationListResult, err error) {
+ req, err := lastResults.interfaceIPConfigurationListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetIPConfigurationsNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListVirtualMachineScaleSetIPConfigurationsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetIPConfigurationsNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListVirtualMachineScaleSetIPConfigurationsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetIPConfigurationsNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListVirtualMachineScaleSetIPConfigurationsComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InterfacesClient) ListVirtualMachineScaleSetIPConfigurationsComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result InterfaceIPConfigurationListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListVirtualMachineScaleSetIPConfigurations")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListVirtualMachineScaleSetIPConfigurations(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, expand)
+ return
+}
+
+// ListVirtualMachineScaleSetNetworkInterfaces gets all network interfaces in a virtual machine scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+func (client InterfacesClient) ListVirtualMachineScaleSetNetworkInterfaces(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (result InterfaceListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListVirtualMachineScaleSetNetworkInterfaces")
+ defer func() {
+ sc := -1
+ if result.ilr.Response.Response != nil {
+ sc = result.ilr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listVirtualMachineScaleSetNetworkInterfacesNextResults
+ req, err := client.ListVirtualMachineScaleSetNetworkInterfacesPreparer(ctx, resourceGroupName, virtualMachineScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetNetworkInterfaces", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVirtualMachineScaleSetNetworkInterfacesSender(req)
+ if err != nil {
+ result.ilr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetNetworkInterfaces", resp, "Failure sending request")
+ return
+ }
+
+ result.ilr, err = client.ListVirtualMachineScaleSetNetworkInterfacesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetNetworkInterfaces", resp, "Failure responding to request")
+ return
+ }
+ if result.ilr.hasNextLink() && result.ilr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListVirtualMachineScaleSetNetworkInterfacesPreparer prepares the ListVirtualMachineScaleSetNetworkInterfaces request.
+func (client InterfacesClient) ListVirtualMachineScaleSetNetworkInterfacesPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/networkInterfaces", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListVirtualMachineScaleSetNetworkInterfacesSender sends the ListVirtualMachineScaleSetNetworkInterfaces request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) ListVirtualMachineScaleSetNetworkInterfacesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListVirtualMachineScaleSetNetworkInterfacesResponder handles the response to the ListVirtualMachineScaleSetNetworkInterfaces request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) ListVirtualMachineScaleSetNetworkInterfacesResponder(resp *http.Response) (result InterfaceListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listVirtualMachineScaleSetNetworkInterfacesNextResults retrieves the next set of results, if any.
+func (client InterfacesClient) listVirtualMachineScaleSetNetworkInterfacesNextResults(ctx context.Context, lastResults InterfaceListResult) (result InterfaceListResult, err error) {
+ req, err := lastResults.interfaceListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetNetworkInterfacesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListVirtualMachineScaleSetNetworkInterfacesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetNetworkInterfacesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListVirtualMachineScaleSetNetworkInterfacesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetNetworkInterfacesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListVirtualMachineScaleSetNetworkInterfacesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InterfacesClient) ListVirtualMachineScaleSetNetworkInterfacesComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (result InterfaceListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListVirtualMachineScaleSetNetworkInterfaces")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListVirtualMachineScaleSetNetworkInterfaces(ctx, resourceGroupName, virtualMachineScaleSetName)
+ return
+}
+
+// ListVirtualMachineScaleSetVMNetworkInterfaces gets information about all network interfaces in a virtual machine in
+// a virtual machine scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+// virtualmachineIndex - the virtual machine index.
+func (client InterfacesClient) ListVirtualMachineScaleSetVMNetworkInterfaces(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string) (result InterfaceListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListVirtualMachineScaleSetVMNetworkInterfaces")
+ defer func() {
+ sc := -1
+ if result.ilr.Response.Response != nil {
+ sc = result.ilr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listVirtualMachineScaleSetVMNetworkInterfacesNextResults
+ req, err := client.ListVirtualMachineScaleSetVMNetworkInterfacesPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetVMNetworkInterfaces", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVirtualMachineScaleSetVMNetworkInterfacesSender(req)
+ if err != nil {
+ result.ilr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetVMNetworkInterfaces", resp, "Failure sending request")
+ return
+ }
+
+ result.ilr, err = client.ListVirtualMachineScaleSetVMNetworkInterfacesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "ListVirtualMachineScaleSetVMNetworkInterfaces", resp, "Failure responding to request")
+ return
+ }
+ if result.ilr.hasNextLink() && result.ilr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListVirtualMachineScaleSetVMNetworkInterfacesPreparer prepares the ListVirtualMachineScaleSetVMNetworkInterfaces request.
+func (client InterfacesClient) ListVirtualMachineScaleSetVMNetworkInterfacesPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListVirtualMachineScaleSetVMNetworkInterfacesSender sends the ListVirtualMachineScaleSetVMNetworkInterfaces request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) ListVirtualMachineScaleSetVMNetworkInterfacesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListVirtualMachineScaleSetVMNetworkInterfacesResponder handles the response to the ListVirtualMachineScaleSetVMNetworkInterfaces request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) ListVirtualMachineScaleSetVMNetworkInterfacesResponder(resp *http.Response) (result InterfaceListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listVirtualMachineScaleSetVMNetworkInterfacesNextResults retrieves the next set of results, if any.
+func (client InterfacesClient) listVirtualMachineScaleSetVMNetworkInterfacesNextResults(ctx context.Context, lastResults InterfaceListResult) (result InterfaceListResult, err error) {
+ req, err := lastResults.interfaceListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetVMNetworkInterfacesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListVirtualMachineScaleSetVMNetworkInterfacesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetVMNetworkInterfacesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListVirtualMachineScaleSetVMNetworkInterfacesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "listVirtualMachineScaleSetVMNetworkInterfacesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListVirtualMachineScaleSetVMNetworkInterfacesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client InterfacesClient) ListVirtualMachineScaleSetVMNetworkInterfacesComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string) (result InterfaceListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.ListVirtualMachineScaleSetVMNetworkInterfaces")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListVirtualMachineScaleSetVMNetworkInterfaces(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex)
+ return
+}
+
+// UpdateTags updates a network interface tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkInterfaceName - the name of the network interface.
+// parameters - parameters supplied to update network interface tags.
+func (client InterfacesClient) UpdateTags(ctx context.Context, resourceGroupName string, networkInterfaceName string, parameters TagsObject) (result InterfacesUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfacesClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, networkInterfaceName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client InterfacesClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, networkInterfaceName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkInterfaces/{networkInterfaceName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client InterfacesClient) UpdateTagsSender(req *http.Request) (future InterfacesUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client InterfacesClient) (i Interface, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.InterfacesUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ i.Response.Response, err = future.GetResult(sender)
+ if i.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && i.Response.Response.StatusCode != http.StatusNoContent {
+ i, err = client.UpdateTagsResponder(i.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.InterfacesUpdateTagsFuture", "Result", i.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client InterfacesClient) UpdateTagsResponder(resp *http.Response) (result Interface, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerbackendaddresspools.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerbackendaddresspools.go
new file mode 100644
index 00000000000..a67d3377270
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerbackendaddresspools.go
@@ -0,0 +1,239 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LoadBalancerBackendAddressPoolsClient is the network Client
+type LoadBalancerBackendAddressPoolsClient struct {
+ BaseClient
+}
+
+// NewLoadBalancerBackendAddressPoolsClient creates an instance of the LoadBalancerBackendAddressPoolsClient client.
+func NewLoadBalancerBackendAddressPoolsClient(subscriptionID string) LoadBalancerBackendAddressPoolsClient {
+ return NewLoadBalancerBackendAddressPoolsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLoadBalancerBackendAddressPoolsClientWithBaseURI creates an instance of the LoadBalancerBackendAddressPoolsClient
+// client using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI
+// (sovereign clouds, Azure stack).
+func NewLoadBalancerBackendAddressPoolsClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerBackendAddressPoolsClient {
+ return LoadBalancerBackendAddressPoolsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets load balancer backend address pool.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// backendAddressPoolName - the name of the backend address pool.
+func (client LoadBalancerBackendAddressPoolsClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, backendAddressPoolName string) (result BackendAddressPool, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerBackendAddressPoolsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, loadBalancerName, backendAddressPoolName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client LoadBalancerBackendAddressPoolsClient) GetPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, backendAddressPoolName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backendAddressPoolName": autorest.Encode("path", backendAddressPoolName),
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerBackendAddressPoolsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerBackendAddressPoolsClient) GetResponder(resp *http.Response) (result BackendAddressPool, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the load balancer backed address pools.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+func (client LoadBalancerBackendAddressPoolsClient) List(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerBackendAddressPoolListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerBackendAddressPoolsClient.List")
+ defer func() {
+ sc := -1
+ if result.lbbaplr.Response.Response != nil {
+ sc = result.lbbaplr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, loadBalancerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.lbbaplr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.lbbaplr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.lbbaplr.hasNextLink() && result.lbbaplr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client LoadBalancerBackendAddressPoolsClient) ListPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerBackendAddressPoolsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerBackendAddressPoolsClient) ListResponder(resp *http.Response) (result LoadBalancerBackendAddressPoolListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client LoadBalancerBackendAddressPoolsClient) listNextResults(ctx context.Context, lastResults LoadBalancerBackendAddressPoolListResult) (result LoadBalancerBackendAddressPoolListResult, err error) {
+ req, err := lastResults.loadBalancerBackendAddressPoolListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerBackendAddressPoolsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LoadBalancerBackendAddressPoolsClient) ListComplete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerBackendAddressPoolListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerBackendAddressPoolsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, loadBalancerName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerfrontendipconfigurations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerfrontendipconfigurations.go
new file mode 100644
index 00000000000..0fe5cae2de9
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerfrontendipconfigurations.go
@@ -0,0 +1,240 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LoadBalancerFrontendIPConfigurationsClient is the network Client
+type LoadBalancerFrontendIPConfigurationsClient struct {
+ BaseClient
+}
+
+// NewLoadBalancerFrontendIPConfigurationsClient creates an instance of the LoadBalancerFrontendIPConfigurationsClient
+// client.
+func NewLoadBalancerFrontendIPConfigurationsClient(subscriptionID string) LoadBalancerFrontendIPConfigurationsClient {
+ return NewLoadBalancerFrontendIPConfigurationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLoadBalancerFrontendIPConfigurationsClientWithBaseURI creates an instance of the
+// LoadBalancerFrontendIPConfigurationsClient client using a custom endpoint. Use this when interacting with an Azure
+// cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewLoadBalancerFrontendIPConfigurationsClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerFrontendIPConfigurationsClient {
+ return LoadBalancerFrontendIPConfigurationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets load balancer frontend IP configuration.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// frontendIPConfigurationName - the name of the frontend IP configuration.
+func (client LoadBalancerFrontendIPConfigurationsClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, frontendIPConfigurationName string) (result FrontendIPConfiguration, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerFrontendIPConfigurationsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, loadBalancerName, frontendIPConfigurationName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client LoadBalancerFrontendIPConfigurationsClient) GetPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, frontendIPConfigurationName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "frontendIPConfigurationName": autorest.Encode("path", frontendIPConfigurationName),
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/frontendIPConfigurations/{frontendIPConfigurationName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerFrontendIPConfigurationsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerFrontendIPConfigurationsClient) GetResponder(resp *http.Response) (result FrontendIPConfiguration, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the load balancer frontend IP configurations.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+func (client LoadBalancerFrontendIPConfigurationsClient) List(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerFrontendIPConfigurationListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerFrontendIPConfigurationsClient.List")
+ defer func() {
+ sc := -1
+ if result.lbficlr.Response.Response != nil {
+ sc = result.lbficlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, loadBalancerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.lbficlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.lbficlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.lbficlr.hasNextLink() && result.lbficlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client LoadBalancerFrontendIPConfigurationsClient) ListPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/frontendIPConfigurations", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerFrontendIPConfigurationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerFrontendIPConfigurationsClient) ListResponder(resp *http.Response) (result LoadBalancerFrontendIPConfigurationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client LoadBalancerFrontendIPConfigurationsClient) listNextResults(ctx context.Context, lastResults LoadBalancerFrontendIPConfigurationListResult) (result LoadBalancerFrontendIPConfigurationListResult, err error) {
+ req, err := lastResults.loadBalancerFrontendIPConfigurationListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerFrontendIPConfigurationsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LoadBalancerFrontendIPConfigurationsClient) ListComplete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerFrontendIPConfigurationListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerFrontendIPConfigurationsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, loadBalancerName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerloadbalancingrules.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerloadbalancingrules.go
new file mode 100644
index 00000000000..cb42aa4bdc5
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerloadbalancingrules.go
@@ -0,0 +1,239 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LoadBalancerLoadBalancingRulesClient is the network Client
+type LoadBalancerLoadBalancingRulesClient struct {
+ BaseClient
+}
+
+// NewLoadBalancerLoadBalancingRulesClient creates an instance of the LoadBalancerLoadBalancingRulesClient client.
+func NewLoadBalancerLoadBalancingRulesClient(subscriptionID string) LoadBalancerLoadBalancingRulesClient {
+ return NewLoadBalancerLoadBalancingRulesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLoadBalancerLoadBalancingRulesClientWithBaseURI creates an instance of the LoadBalancerLoadBalancingRulesClient
+// client using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI
+// (sovereign clouds, Azure stack).
+func NewLoadBalancerLoadBalancingRulesClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerLoadBalancingRulesClient {
+ return LoadBalancerLoadBalancingRulesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets the specified load balancer load balancing rule.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// loadBalancingRuleName - the name of the load balancing rule.
+func (client LoadBalancerLoadBalancingRulesClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, loadBalancingRuleName string) (result LoadBalancingRule, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerLoadBalancingRulesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, loadBalancerName, loadBalancingRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client LoadBalancerLoadBalancingRulesClient) GetPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, loadBalancingRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "loadBalancingRuleName": autorest.Encode("path", loadBalancingRuleName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/loadBalancingRules/{loadBalancingRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerLoadBalancingRulesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerLoadBalancingRulesClient) GetResponder(resp *http.Response) (result LoadBalancingRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the load balancing rules in a load balancer.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+func (client LoadBalancerLoadBalancingRulesClient) List(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerLoadBalancingRuleListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerLoadBalancingRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.lblbrlr.Response.Response != nil {
+ sc = result.lblbrlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, loadBalancerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.lblbrlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.lblbrlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.lblbrlr.hasNextLink() && result.lblbrlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client LoadBalancerLoadBalancingRulesClient) ListPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/loadBalancingRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerLoadBalancingRulesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerLoadBalancingRulesClient) ListResponder(resp *http.Response) (result LoadBalancerLoadBalancingRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client LoadBalancerLoadBalancingRulesClient) listNextResults(ctx context.Context, lastResults LoadBalancerLoadBalancingRuleListResult) (result LoadBalancerLoadBalancingRuleListResult, err error) {
+ req, err := lastResults.loadBalancerLoadBalancingRuleListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerLoadBalancingRulesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LoadBalancerLoadBalancingRulesClient) ListComplete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerLoadBalancingRuleListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerLoadBalancingRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, loadBalancerName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancernetworkinterfaces.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancernetworkinterfaces.go
new file mode 100644
index 00000000000..ad765e75570
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancernetworkinterfaces.go
@@ -0,0 +1,161 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LoadBalancerNetworkInterfacesClient is the network Client
+type LoadBalancerNetworkInterfacesClient struct {
+ BaseClient
+}
+
+// NewLoadBalancerNetworkInterfacesClient creates an instance of the LoadBalancerNetworkInterfacesClient client.
+func NewLoadBalancerNetworkInterfacesClient(subscriptionID string) LoadBalancerNetworkInterfacesClient {
+ return NewLoadBalancerNetworkInterfacesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLoadBalancerNetworkInterfacesClientWithBaseURI creates an instance of the LoadBalancerNetworkInterfacesClient
+// client using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI
+// (sovereign clouds, Azure stack).
+func NewLoadBalancerNetworkInterfacesClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerNetworkInterfacesClient {
+ return LoadBalancerNetworkInterfacesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List gets associated load balancer network interfaces.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+func (client LoadBalancerNetworkInterfacesClient) List(ctx context.Context, resourceGroupName string, loadBalancerName string) (result InterfaceListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerNetworkInterfacesClient.List")
+ defer func() {
+ sc := -1
+ if result.ilr.Response.Response != nil {
+ sc = result.ilr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, loadBalancerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerNetworkInterfacesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.ilr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerNetworkInterfacesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.ilr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerNetworkInterfacesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.ilr.hasNextLink() && result.ilr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client LoadBalancerNetworkInterfacesClient) ListPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/networkInterfaces", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerNetworkInterfacesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerNetworkInterfacesClient) ListResponder(resp *http.Response) (result InterfaceListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client LoadBalancerNetworkInterfacesClient) listNextResults(ctx context.Context, lastResults InterfaceListResult) (result InterfaceListResult, err error) {
+ req, err := lastResults.interfaceListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerNetworkInterfacesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerNetworkInterfacesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerNetworkInterfacesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LoadBalancerNetworkInterfacesClient) ListComplete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result InterfaceListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerNetworkInterfacesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, loadBalancerName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerprobes.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerprobes.go
new file mode 100644
index 00000000000..0df08e2175e
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancerprobes.go
@@ -0,0 +1,239 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LoadBalancerProbesClient is the network Client
+type LoadBalancerProbesClient struct {
+ BaseClient
+}
+
+// NewLoadBalancerProbesClient creates an instance of the LoadBalancerProbesClient client.
+func NewLoadBalancerProbesClient(subscriptionID string) LoadBalancerProbesClient {
+ return NewLoadBalancerProbesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLoadBalancerProbesClientWithBaseURI creates an instance of the LoadBalancerProbesClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewLoadBalancerProbesClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerProbesClient {
+ return LoadBalancerProbesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get gets load balancer probe.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// probeName - the name of the probe.
+func (client LoadBalancerProbesClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, probeName string) (result Probe, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, loadBalancerName, probeName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client LoadBalancerProbesClient) GetPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, probeName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "probeName": autorest.Encode("path", probeName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerProbesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerProbesClient) GetResponder(resp *http.Response) (result Probe, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the load balancer probes.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+func (client LoadBalancerProbesClient) List(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerProbeListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbesClient.List")
+ defer func() {
+ sc := -1
+ if result.lbplr.Response.Response != nil {
+ sc = result.lbplr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, loadBalancerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.lbplr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.lbplr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.lbplr.hasNextLink() && result.lbplr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client LoadBalancerProbesClient) ListPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancerProbesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client LoadBalancerProbesClient) ListResponder(resp *http.Response) (result LoadBalancerProbeListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client LoadBalancerProbesClient) listNextResults(ctx context.Context, lastResults LoadBalancerProbeListResult) (result LoadBalancerProbeListResult, err error) {
+ req, err := lastResults.loadBalancerProbeListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LoadBalancerProbesClient) ListComplete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerProbeListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, loadBalancerName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancers.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancers.go
new file mode 100644
index 00000000000..2d62dab170c
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/loadbalancers.go
@@ -0,0 +1,649 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LoadBalancersClient is the network Client
+type LoadBalancersClient struct {
+ BaseClient
+}
+
+// NewLoadBalancersClient creates an instance of the LoadBalancersClient client.
+func NewLoadBalancersClient(subscriptionID string) LoadBalancersClient {
+ return NewLoadBalancersClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLoadBalancersClientWithBaseURI creates an instance of the LoadBalancersClient client using a custom endpoint.
+// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewLoadBalancersClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancersClient {
+ return LoadBalancersClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a load balancer.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// parameters - parameters supplied to the create or update load balancer operation.
+func (client LoadBalancersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters LoadBalancer) (result LoadBalancersCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, loadBalancerName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client LoadBalancersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters LoadBalancer) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancersClient) CreateOrUpdateSender(req *http.Request) (future LoadBalancersCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LoadBalancersClient) (lb LoadBalancer, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.LoadBalancersCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ lb.Response.Response, err = future.GetResult(sender)
+ if lb.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && lb.Response.Response.StatusCode != http.StatusNoContent {
+ lb, err = client.CreateOrUpdateResponder(lb.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersCreateOrUpdateFuture", "Result", lb.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client LoadBalancersClient) CreateOrUpdateResponder(resp *http.Response) (result LoadBalancer, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified load balancer.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+func (client LoadBalancersClient) Delete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancersDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, loadBalancerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client LoadBalancersClient) DeletePreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancersClient) DeleteSender(req *http.Request) (future LoadBalancersDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LoadBalancersClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.LoadBalancersDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client LoadBalancersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified load balancer.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// expand - expands referenced resources.
+func (client LoadBalancersClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, expand string) (result LoadBalancer, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, loadBalancerName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client LoadBalancersClient) GetPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancersClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client LoadBalancersClient) GetResponder(resp *http.Response) (result LoadBalancer, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the load balancers in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client LoadBalancersClient) List(ctx context.Context, resourceGroupName string) (result LoadBalancerListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.List")
+ defer func() {
+ sc := -1
+ if result.lblr.Response.Response != nil {
+ sc = result.lblr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.lblr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.lblr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.lblr.hasNextLink() && result.lblr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client LoadBalancersClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancersClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client LoadBalancersClient) ListResponder(resp *http.Response) (result LoadBalancerListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client LoadBalancersClient) listNextResults(ctx context.Context, lastResults LoadBalancerListResult) (result LoadBalancerListResult, err error) {
+ req, err := lastResults.loadBalancerListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancersClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancersClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LoadBalancersClient) ListComplete(ctx context.Context, resourceGroupName string) (result LoadBalancerListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all the load balancers in a subscription.
+func (client LoadBalancersClient) ListAll(ctx context.Context) (result LoadBalancerListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.lblr.Response.Response != nil {
+ sc = result.lblr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.lblr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.lblr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.lblr.hasNextLink() && result.lblr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client LoadBalancersClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/loadBalancers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancersClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client LoadBalancersClient) ListAllResponder(resp *http.Response) (result LoadBalancerListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client LoadBalancersClient) listAllNextResults(ctx context.Context, lastResults LoadBalancerListResult) (result LoadBalancerListResult, err error) {
+ req, err := lastResults.loadBalancerListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancersClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LoadBalancersClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LoadBalancersClient) ListAllComplete(ctx context.Context) (result LoadBalancerListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// UpdateTags updates a load balancer tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// loadBalancerName - the name of the load balancer.
+// parameters - parameters supplied to update load balancer tags.
+func (client LoadBalancersClient) UpdateTags(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters TagsObject) (result LoadBalancersUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancersClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, loadBalancerName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client LoadBalancersClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "loadBalancerName": autorest.Encode("path", loadBalancerName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client LoadBalancersClient) UpdateTagsSender(req *http.Request) (future LoadBalancersUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LoadBalancersClient) (lb LoadBalancer, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.LoadBalancersUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ lb.Response.Response, err = future.GetResult(sender)
+ if lb.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && lb.Response.Response.StatusCode != http.StatusNoContent {
+ lb, err = client.UpdateTagsResponder(lb.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LoadBalancersUpdateTagsFuture", "Result", lb.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client LoadBalancersClient) UpdateTagsResponder(resp *http.Response) (result LoadBalancer, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/localnetworkgateways.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/localnetworkgateways.go
new file mode 100644
index 00000000000..981704d0bf9
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/localnetworkgateways.go
@@ -0,0 +1,560 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// LocalNetworkGatewaysClient is the network Client
+type LocalNetworkGatewaysClient struct {
+ BaseClient
+}
+
+// NewLocalNetworkGatewaysClient creates an instance of the LocalNetworkGatewaysClient client.
+func NewLocalNetworkGatewaysClient(subscriptionID string) LocalNetworkGatewaysClient {
+ return NewLocalNetworkGatewaysClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewLocalNetworkGatewaysClientWithBaseURI creates an instance of the LocalNetworkGatewaysClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewLocalNetworkGatewaysClientWithBaseURI(baseURI string, subscriptionID string) LocalNetworkGatewaysClient {
+ return LocalNetworkGatewaysClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a local network gateway in the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// localNetworkGatewayName - the name of the local network gateway.
+// parameters - parameters supplied to the create or update local network gateway operation.
+func (client LocalNetworkGatewaysClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, localNetworkGatewayName string, parameters LocalNetworkGateway) (result LocalNetworkGatewaysCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewaysClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: localNetworkGatewayName,
+ Constraints: []validation.Constraint{{Target: "localNetworkGatewayName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.LocalNetworkGatewayPropertiesFormat", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.LocalNetworkGatewaysClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, localNetworkGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client LocalNetworkGatewaysClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, localNetworkGatewayName string, parameters LocalNetworkGateway) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "localNetworkGatewayName": autorest.Encode("path", localNetworkGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/localNetworkGateways/{localNetworkGatewayName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client LocalNetworkGatewaysClient) CreateOrUpdateSender(req *http.Request) (future LocalNetworkGatewaysCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LocalNetworkGatewaysClient) (lng LocalNetworkGateway, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.LocalNetworkGatewaysCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ lng.Response.Response, err = future.GetResult(sender)
+ if lng.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && lng.Response.Response.StatusCode != http.StatusNoContent {
+ lng, err = client.CreateOrUpdateResponder(lng.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysCreateOrUpdateFuture", "Result", lng.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client LocalNetworkGatewaysClient) CreateOrUpdateResponder(resp *http.Response) (result LocalNetworkGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified local network gateway.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// localNetworkGatewayName - the name of the local network gateway.
+func (client LocalNetworkGatewaysClient) Delete(ctx context.Context, resourceGroupName string, localNetworkGatewayName string) (result LocalNetworkGatewaysDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewaysClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: localNetworkGatewayName,
+ Constraints: []validation.Constraint{{Target: "localNetworkGatewayName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.LocalNetworkGatewaysClient", "Delete", err.Error())
+ }
+
+ req, err := client.DeletePreparer(ctx, resourceGroupName, localNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client LocalNetworkGatewaysClient) DeletePreparer(ctx context.Context, resourceGroupName string, localNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "localNetworkGatewayName": autorest.Encode("path", localNetworkGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/localNetworkGateways/{localNetworkGatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client LocalNetworkGatewaysClient) DeleteSender(req *http.Request) (future LocalNetworkGatewaysDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LocalNetworkGatewaysClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.LocalNetworkGatewaysDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client LocalNetworkGatewaysClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified local network gateway in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// localNetworkGatewayName - the name of the local network gateway.
+func (client LocalNetworkGatewaysClient) Get(ctx context.Context, resourceGroupName string, localNetworkGatewayName string) (result LocalNetworkGateway, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewaysClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: localNetworkGatewayName,
+ Constraints: []validation.Constraint{{Target: "localNetworkGatewayName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.LocalNetworkGatewaysClient", "Get", err.Error())
+ }
+
+ req, err := client.GetPreparer(ctx, resourceGroupName, localNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client LocalNetworkGatewaysClient) GetPreparer(ctx context.Context, resourceGroupName string, localNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "localNetworkGatewayName": autorest.Encode("path", localNetworkGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/localNetworkGateways/{localNetworkGatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client LocalNetworkGatewaysClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client LocalNetworkGatewaysClient) GetResponder(resp *http.Response) (result LocalNetworkGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all the local network gateways in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client LocalNetworkGatewaysClient) List(ctx context.Context, resourceGroupName string) (result LocalNetworkGatewayListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewaysClient.List")
+ defer func() {
+ sc := -1
+ if result.lnglr.Response.Response != nil {
+ sc = result.lnglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.lnglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.lnglr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.lnglr.hasNextLink() && result.lnglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client LocalNetworkGatewaysClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/localNetworkGateways", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client LocalNetworkGatewaysClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client LocalNetworkGatewaysClient) ListResponder(resp *http.Response) (result LocalNetworkGatewayListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client LocalNetworkGatewaysClient) listNextResults(ctx context.Context, lastResults LocalNetworkGatewayListResult) (result LocalNetworkGatewayListResult, err error) {
+ req, err := lastResults.localNetworkGatewayListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client LocalNetworkGatewaysClient) ListComplete(ctx context.Context, resourceGroupName string) (result LocalNetworkGatewayListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewaysClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// UpdateTags updates a local network gateway tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// localNetworkGatewayName - the name of the local network gateway.
+// parameters - parameters supplied to update local network gateway tags.
+func (client LocalNetworkGatewaysClient) UpdateTags(ctx context.Context, resourceGroupName string, localNetworkGatewayName string, parameters TagsObject) (result LocalNetworkGatewaysUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewaysClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: localNetworkGatewayName,
+ Constraints: []validation.Constraint{{Target: "localNetworkGatewayName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.LocalNetworkGatewaysClient", "UpdateTags", err.Error())
+ }
+
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, localNetworkGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client LocalNetworkGatewaysClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, localNetworkGatewayName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "localNetworkGatewayName": autorest.Encode("path", localNetworkGatewayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/localNetworkGateways/{localNetworkGatewayName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client LocalNetworkGatewaysClient) UpdateTagsSender(req *http.Request) (future LocalNetworkGatewaysUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client LocalNetworkGatewaysClient) (lng LocalNetworkGateway, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.LocalNetworkGatewaysUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ lng.Response.Response, err = future.GetResult(sender)
+ if lng.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && lng.Response.Response.StatusCode != http.StatusNoContent {
+ lng, err = client.UpdateTagsResponder(lng.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.LocalNetworkGatewaysUpdateTagsFuture", "Result", lng.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client LocalNetworkGatewaysClient) UpdateTagsResponder(resp *http.Response) (result LocalNetworkGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/models.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/models.go
new file mode 100644
index 00000000000..562d899daf8
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/models.go
@@ -0,0 +1,15288 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "encoding/json"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/date"
+ "github.com/Azure/go-autorest/autorest/to"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// The package's fully qualified name.
+const fqdn = "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network"
+
+// AddressSpace addressSpace contains an array of IP address ranges that can be used by subnets of the
+// virtual network.
+type AddressSpace struct {
+ // AddressPrefixes - A list of address blocks reserved for this virtual network in CIDR notation.
+ AddressPrefixes *[]string `json:"addressPrefixes,omitempty"`
+}
+
+// ApplicationGateway application gateway resource
+type ApplicationGateway struct {
+ autorest.Response `json:"-"`
+ *ApplicationGatewayPropertiesFormat `json:"properties,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGateway.
+func (ag ApplicationGateway) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ag.ApplicationGatewayPropertiesFormat != nil {
+ objectMap["properties"] = ag.ApplicationGatewayPropertiesFormat
+ }
+ if ag.Etag != nil {
+ objectMap["etag"] = ag.Etag
+ }
+ if ag.ID != nil {
+ objectMap["id"] = ag.ID
+ }
+ if ag.Location != nil {
+ objectMap["location"] = ag.Location
+ }
+ if ag.Tags != nil {
+ objectMap["tags"] = ag.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGateway struct.
+func (ag *ApplicationGateway) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayPropertiesFormat ApplicationGatewayPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ ag.ApplicationGatewayPropertiesFormat = &applicationGatewayPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ ag.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ ag.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ ag.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ ag.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ ag.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ ag.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayAuthenticationCertificate authentication certificates of an application gateway.
+type ApplicationGatewayAuthenticationCertificate struct {
+ *ApplicationGatewayAuthenticationCertificatePropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayAuthenticationCertificate.
+func (agac ApplicationGatewayAuthenticationCertificate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agac.ApplicationGatewayAuthenticationCertificatePropertiesFormat != nil {
+ objectMap["properties"] = agac.ApplicationGatewayAuthenticationCertificatePropertiesFormat
+ }
+ if agac.Name != nil {
+ objectMap["name"] = agac.Name
+ }
+ if agac.Etag != nil {
+ objectMap["etag"] = agac.Etag
+ }
+ if agac.Type != nil {
+ objectMap["type"] = agac.Type
+ }
+ if agac.ID != nil {
+ objectMap["id"] = agac.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayAuthenticationCertificate struct.
+func (agac *ApplicationGatewayAuthenticationCertificate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayAuthenticationCertificatePropertiesFormat ApplicationGatewayAuthenticationCertificatePropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayAuthenticationCertificatePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agac.ApplicationGatewayAuthenticationCertificatePropertiesFormat = &applicationGatewayAuthenticationCertificatePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agac.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agac.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agac.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agac.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayAuthenticationCertificatePropertiesFormat authentication certificates properties of an
+// application gateway.
+type ApplicationGatewayAuthenticationCertificatePropertiesFormat struct {
+ // Data - Certificate public data.
+ Data *string `json:"data,omitempty"`
+ // ProvisioningState - Provisioning state of the authentication certificate resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayAvailableSslOptions response for ApplicationGatewayAvailableSslOptions API service
+// call.
+type ApplicationGatewayAvailableSslOptions struct {
+ autorest.Response `json:"-"`
+ *ApplicationGatewayAvailableSslOptionsPropertiesFormat `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayAvailableSslOptions.
+func (agaso ApplicationGatewayAvailableSslOptions) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agaso.ApplicationGatewayAvailableSslOptionsPropertiesFormat != nil {
+ objectMap["properties"] = agaso.ApplicationGatewayAvailableSslOptionsPropertiesFormat
+ }
+ if agaso.ID != nil {
+ objectMap["id"] = agaso.ID
+ }
+ if agaso.Location != nil {
+ objectMap["location"] = agaso.Location
+ }
+ if agaso.Tags != nil {
+ objectMap["tags"] = agaso.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayAvailableSslOptions struct.
+func (agaso *ApplicationGatewayAvailableSslOptions) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayAvailableSslOptionsPropertiesFormat ApplicationGatewayAvailableSslOptionsPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayAvailableSslOptionsPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agaso.ApplicationGatewayAvailableSslOptionsPropertiesFormat = &applicationGatewayAvailableSslOptionsPropertiesFormat
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agaso.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agaso.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agaso.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ agaso.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ agaso.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayAvailableSslOptionsPropertiesFormat properties of
+// ApplicationGatewayAvailableSslOptions
+type ApplicationGatewayAvailableSslOptionsPropertiesFormat struct {
+ // PredefinedPolicies - List of available Ssl predefined policy.
+ PredefinedPolicies *[]SubResource `json:"predefinedPolicies,omitempty"`
+ // DefaultPolicy - Name of the Ssl predefined policy applied by default to application gateway. Possible values include: 'AppGwSslPolicy20150501', 'AppGwSslPolicy20170401', 'AppGwSslPolicy20170401S'
+ DefaultPolicy ApplicationGatewaySslPolicyName `json:"defaultPolicy,omitempty"`
+ // AvailableCipherSuites - List of available Ssl cipher suites.
+ AvailableCipherSuites *[]ApplicationGatewaySslCipherSuite `json:"availableCipherSuites,omitempty"`
+ // AvailableProtocols - List of available Ssl protocols.
+ AvailableProtocols *[]ApplicationGatewaySslProtocol `json:"availableProtocols,omitempty"`
+}
+
+// ApplicationGatewayAvailableSslPredefinedPolicies response for ApplicationGatewayAvailableSslOptions API
+// service call.
+type ApplicationGatewayAvailableSslPredefinedPolicies struct {
+ autorest.Response `json:"-"`
+ // Value - List of available Ssl predefined policy.
+ Value *[]ApplicationGatewaySslPredefinedPolicy `json:"value,omitempty"`
+ // NextLink - URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ApplicationGatewayAvailableSslPredefinedPoliciesIterator provides access to a complete listing of
+// ApplicationGatewaySslPredefinedPolicy values.
+type ApplicationGatewayAvailableSslPredefinedPoliciesIterator struct {
+ i int
+ page ApplicationGatewayAvailableSslPredefinedPoliciesPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ApplicationGatewayAvailableSslPredefinedPoliciesIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewayAvailableSslPredefinedPoliciesIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ApplicationGatewayAvailableSslPredefinedPoliciesIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ApplicationGatewayAvailableSslPredefinedPoliciesIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ApplicationGatewayAvailableSslPredefinedPoliciesIterator) Response() ApplicationGatewayAvailableSslPredefinedPolicies {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ApplicationGatewayAvailableSslPredefinedPoliciesIterator) Value() ApplicationGatewaySslPredefinedPolicy {
+ if !iter.page.NotDone() {
+ return ApplicationGatewaySslPredefinedPolicy{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ApplicationGatewayAvailableSslPredefinedPoliciesIterator type.
+func NewApplicationGatewayAvailableSslPredefinedPoliciesIterator(page ApplicationGatewayAvailableSslPredefinedPoliciesPage) ApplicationGatewayAvailableSslPredefinedPoliciesIterator {
+ return ApplicationGatewayAvailableSslPredefinedPoliciesIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (agaspp ApplicationGatewayAvailableSslPredefinedPolicies) IsEmpty() bool {
+ return agaspp.Value == nil || len(*agaspp.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (agaspp ApplicationGatewayAvailableSslPredefinedPolicies) hasNextLink() bool {
+ return agaspp.NextLink != nil && len(*agaspp.NextLink) != 0
+}
+
+// applicationGatewayAvailableSslPredefinedPoliciesPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (agaspp ApplicationGatewayAvailableSslPredefinedPolicies) applicationGatewayAvailableSslPredefinedPoliciesPreparer(ctx context.Context) (*http.Request, error) {
+ if !agaspp.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(agaspp.NextLink)))
+}
+
+// ApplicationGatewayAvailableSslPredefinedPoliciesPage contains a page of
+// ApplicationGatewaySslPredefinedPolicy values.
+type ApplicationGatewayAvailableSslPredefinedPoliciesPage struct {
+ fn func(context.Context, ApplicationGatewayAvailableSslPredefinedPolicies) (ApplicationGatewayAvailableSslPredefinedPolicies, error)
+ agaspp ApplicationGatewayAvailableSslPredefinedPolicies
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ApplicationGatewayAvailableSslPredefinedPoliciesPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewayAvailableSslPredefinedPoliciesPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.agaspp)
+ if err != nil {
+ return err
+ }
+ page.agaspp = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ApplicationGatewayAvailableSslPredefinedPoliciesPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ApplicationGatewayAvailableSslPredefinedPoliciesPage) NotDone() bool {
+ return !page.agaspp.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ApplicationGatewayAvailableSslPredefinedPoliciesPage) Response() ApplicationGatewayAvailableSslPredefinedPolicies {
+ return page.agaspp
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ApplicationGatewayAvailableSslPredefinedPoliciesPage) Values() []ApplicationGatewaySslPredefinedPolicy {
+ if page.agaspp.IsEmpty() {
+ return nil
+ }
+ return *page.agaspp.Value
+}
+
+// Creates a new instance of the ApplicationGatewayAvailableSslPredefinedPoliciesPage type.
+func NewApplicationGatewayAvailableSslPredefinedPoliciesPage(cur ApplicationGatewayAvailableSslPredefinedPolicies, getNextPage func(context.Context, ApplicationGatewayAvailableSslPredefinedPolicies) (ApplicationGatewayAvailableSslPredefinedPolicies, error)) ApplicationGatewayAvailableSslPredefinedPoliciesPage {
+ return ApplicationGatewayAvailableSslPredefinedPoliciesPage{
+ fn: getNextPage,
+ agaspp: cur,
+ }
+}
+
+// ApplicationGatewayAvailableWafRuleSetsResult response for ApplicationGatewayAvailableWafRuleSets API
+// service call.
+type ApplicationGatewayAvailableWafRuleSetsResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of application gateway rule sets.
+ Value *[]ApplicationGatewayFirewallRuleSet `json:"value,omitempty"`
+}
+
+// ApplicationGatewayBackendAddress backend address of an application gateway.
+type ApplicationGatewayBackendAddress struct {
+ // Fqdn - Fully qualified domain name (FQDN).
+ Fqdn *string `json:"fqdn,omitempty"`
+ // IPAddress - IP address
+ IPAddress *string `json:"ipAddress,omitempty"`
+}
+
+// ApplicationGatewayBackendAddressPool backend Address Pool of an application gateway.
+type ApplicationGatewayBackendAddressPool struct {
+ *ApplicationGatewayBackendAddressPoolPropertiesFormat `json:"properties,omitempty"`
+ // Name - Resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayBackendAddressPool.
+func (agbap ApplicationGatewayBackendAddressPool) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agbap.ApplicationGatewayBackendAddressPoolPropertiesFormat != nil {
+ objectMap["properties"] = agbap.ApplicationGatewayBackendAddressPoolPropertiesFormat
+ }
+ if agbap.Name != nil {
+ objectMap["name"] = agbap.Name
+ }
+ if agbap.Etag != nil {
+ objectMap["etag"] = agbap.Etag
+ }
+ if agbap.Type != nil {
+ objectMap["type"] = agbap.Type
+ }
+ if agbap.ID != nil {
+ objectMap["id"] = agbap.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayBackendAddressPool struct.
+func (agbap *ApplicationGatewayBackendAddressPool) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayBackendAddressPoolPropertiesFormat ApplicationGatewayBackendAddressPoolPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayBackendAddressPoolPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agbap.ApplicationGatewayBackendAddressPoolPropertiesFormat = &applicationGatewayBackendAddressPoolPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agbap.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agbap.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agbap.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agbap.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayBackendAddressPoolPropertiesFormat properties of Backend Address Pool of an
+// application gateway.
+type ApplicationGatewayBackendAddressPoolPropertiesFormat struct {
+ // BackendIPConfigurations - Collection of references to IPs defined in network interfaces.
+ BackendIPConfigurations *[]InterfaceIPConfiguration `json:"backendIPConfigurations,omitempty"`
+ // BackendAddresses - Backend addresses
+ BackendAddresses *[]ApplicationGatewayBackendAddress `json:"backendAddresses,omitempty"`
+ // ProvisioningState - Provisioning state of the backend address pool resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayBackendHealth list of ApplicationGatewayBackendHealthPool resources.
+type ApplicationGatewayBackendHealth struct {
+ autorest.Response `json:"-"`
+ BackendAddressPools *[]ApplicationGatewayBackendHealthPool `json:"backendAddressPools,omitempty"`
+}
+
+// ApplicationGatewayBackendHealthHTTPSettings application gateway BackendHealthHttp settings.
+type ApplicationGatewayBackendHealthHTTPSettings struct {
+ // BackendHTTPSettings - Reference of an ApplicationGatewayBackendHttpSettings resource.
+ BackendHTTPSettings *ApplicationGatewayBackendHTTPSettings `json:"backendHttpSettings,omitempty"`
+ // Servers - List of ApplicationGatewayBackendHealthServer resources.
+ Servers *[]ApplicationGatewayBackendHealthServer `json:"servers,omitempty"`
+}
+
+// ApplicationGatewayBackendHealthPool application gateway BackendHealth pool.
+type ApplicationGatewayBackendHealthPool struct {
+ // BackendAddressPool - Reference of an ApplicationGatewayBackendAddressPool resource.
+ BackendAddressPool *ApplicationGatewayBackendAddressPool `json:"backendAddressPool,omitempty"`
+ // BackendHTTPSettingsCollection - List of ApplicationGatewayBackendHealthHttpSettings resources.
+ BackendHTTPSettingsCollection *[]ApplicationGatewayBackendHealthHTTPSettings `json:"backendHttpSettingsCollection,omitempty"`
+}
+
+// ApplicationGatewayBackendHealthServer application gateway backendhealth http settings.
+type ApplicationGatewayBackendHealthServer struct {
+ // Address - IP address or FQDN of backend server.
+ Address *string `json:"address,omitempty"`
+ // IPConfiguration - Reference of IP configuration of backend server.
+ IPConfiguration *InterfaceIPConfiguration `json:"ipConfiguration,omitempty"`
+ // Health - Health of backend server. Possible values include: 'Unknown', 'Up', 'Down', 'Partial', 'Draining'
+ Health ApplicationGatewayBackendHealthServerHealth `json:"health,omitempty"`
+}
+
+// ApplicationGatewayBackendHTTPSettings backend address pool settings of an application gateway.
+type ApplicationGatewayBackendHTTPSettings struct {
+ *ApplicationGatewayBackendHTTPSettingsPropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayBackendHTTPSettings.
+func (agbhs ApplicationGatewayBackendHTTPSettings) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agbhs.ApplicationGatewayBackendHTTPSettingsPropertiesFormat != nil {
+ objectMap["properties"] = agbhs.ApplicationGatewayBackendHTTPSettingsPropertiesFormat
+ }
+ if agbhs.Name != nil {
+ objectMap["name"] = agbhs.Name
+ }
+ if agbhs.Etag != nil {
+ objectMap["etag"] = agbhs.Etag
+ }
+ if agbhs.Type != nil {
+ objectMap["type"] = agbhs.Type
+ }
+ if agbhs.ID != nil {
+ objectMap["id"] = agbhs.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayBackendHTTPSettings struct.
+func (agbhs *ApplicationGatewayBackendHTTPSettings) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayBackendHTTPSettingsPropertiesFormat ApplicationGatewayBackendHTTPSettingsPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayBackendHTTPSettingsPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agbhs.ApplicationGatewayBackendHTTPSettingsPropertiesFormat = &applicationGatewayBackendHTTPSettingsPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agbhs.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agbhs.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agbhs.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agbhs.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayBackendHTTPSettingsPropertiesFormat properties of Backend address pool settings of an
+// application gateway.
+type ApplicationGatewayBackendHTTPSettingsPropertiesFormat struct {
+ // Port - Port
+ Port *int32 `json:"port,omitempty"`
+ // Protocol - Protocol. Possible values include: 'HTTP', 'HTTPS'
+ Protocol ApplicationGatewayProtocol `json:"protocol,omitempty"`
+ // CookieBasedAffinity - Cookie based affinity. Possible values include: 'Enabled', 'Disabled'
+ CookieBasedAffinity ApplicationGatewayCookieBasedAffinity `json:"cookieBasedAffinity,omitempty"`
+ // RequestTimeout - Request timeout in seconds. Application Gateway will fail the request if response is not received within RequestTimeout. Acceptable values are from 1 second to 86400 seconds.
+ RequestTimeout *int32 `json:"requestTimeout,omitempty"`
+ // Probe - Probe resource of an application gateway.
+ Probe *SubResource `json:"probe,omitempty"`
+ // AuthenticationCertificates - Array of references to application gateway authentication certificates.
+ AuthenticationCertificates *[]SubResource `json:"authenticationCertificates,omitempty"`
+ // ConnectionDraining - Connection draining of the backend http settings resource.
+ ConnectionDraining *ApplicationGatewayConnectionDraining `json:"connectionDraining,omitempty"`
+ // HostName - Host header to be sent to the backend servers.
+ HostName *string `json:"hostName,omitempty"`
+ // PickHostNameFromBackendAddress - Whether to pick host header should be picked from the host name of the backend server. Default value is false.
+ PickHostNameFromBackendAddress *bool `json:"pickHostNameFromBackendAddress,omitempty"`
+ // AffinityCookieName - Cookie name to use for the affinity cookie.
+ AffinityCookieName *string `json:"affinityCookieName,omitempty"`
+ // ProbeEnabled - Whether the probe is enabled. Default value is false.
+ ProbeEnabled *bool `json:"probeEnabled,omitempty"`
+ // Path - Path which should be used as a prefix for all HTTP requests. Null means no path will be prefixed. Default value is null.
+ Path *string `json:"path,omitempty"`
+ // ProvisioningState - Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayConnectionDraining connection draining allows open connections to a backend server to
+// be active for a specified time after the backend server got removed from the configuration.
+type ApplicationGatewayConnectionDraining struct {
+ // Enabled - Whether connection draining is enabled or not.
+ Enabled *bool `json:"enabled,omitempty"`
+ // DrainTimeoutInSec - The number of seconds connection draining is active. Acceptable values are from 1 second to 3600 seconds.
+ DrainTimeoutInSec *int32 `json:"drainTimeoutInSec,omitempty"`
+}
+
+// ApplicationGatewayFirewallDisabledRuleGroup allows to disable rules within a rule group or an entire
+// rule group.
+type ApplicationGatewayFirewallDisabledRuleGroup struct {
+ // RuleGroupName - The name of the rule group that will be disabled.
+ RuleGroupName *string `json:"ruleGroupName,omitempty"`
+ // Rules - The list of rules that will be disabled. If null, all rules of the rule group will be disabled.
+ Rules *[]int32 `json:"rules,omitempty"`
+}
+
+// ApplicationGatewayFirewallRule a web application firewall rule.
+type ApplicationGatewayFirewallRule struct {
+ // RuleID - The identifier of the web application firewall rule.
+ RuleID *int32 `json:"ruleId,omitempty"`
+ // Description - The description of the web application firewall rule.
+ Description *string `json:"description,omitempty"`
+}
+
+// ApplicationGatewayFirewallRuleGroup a web application firewall rule group.
+type ApplicationGatewayFirewallRuleGroup struct {
+ // RuleGroupName - The name of the web application firewall rule group.
+ RuleGroupName *string `json:"ruleGroupName,omitempty"`
+ // Description - The description of the web application firewall rule group.
+ Description *string `json:"description,omitempty"`
+ // Rules - The rules of the web application firewall rule group.
+ Rules *[]ApplicationGatewayFirewallRule `json:"rules,omitempty"`
+}
+
+// ApplicationGatewayFirewallRuleSet a web application firewall rule set.
+type ApplicationGatewayFirewallRuleSet struct {
+ *ApplicationGatewayFirewallRuleSetPropertiesFormat `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayFirewallRuleSet.
+func (agfrs ApplicationGatewayFirewallRuleSet) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agfrs.ApplicationGatewayFirewallRuleSetPropertiesFormat != nil {
+ objectMap["properties"] = agfrs.ApplicationGatewayFirewallRuleSetPropertiesFormat
+ }
+ if agfrs.ID != nil {
+ objectMap["id"] = agfrs.ID
+ }
+ if agfrs.Location != nil {
+ objectMap["location"] = agfrs.Location
+ }
+ if agfrs.Tags != nil {
+ objectMap["tags"] = agfrs.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayFirewallRuleSet struct.
+func (agfrs *ApplicationGatewayFirewallRuleSet) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayFirewallRuleSetPropertiesFormat ApplicationGatewayFirewallRuleSetPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayFirewallRuleSetPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agfrs.ApplicationGatewayFirewallRuleSetPropertiesFormat = &applicationGatewayFirewallRuleSetPropertiesFormat
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agfrs.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agfrs.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agfrs.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ agfrs.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ agfrs.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayFirewallRuleSetPropertiesFormat properties of the web application firewall rule set.
+type ApplicationGatewayFirewallRuleSetPropertiesFormat struct {
+ // ProvisioningState - The provisioning state of the web application firewall rule set.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // RuleSetType - The type of the web application firewall rule set.
+ RuleSetType *string `json:"ruleSetType,omitempty"`
+ // RuleSetVersion - The version of the web application firewall rule set type.
+ RuleSetVersion *string `json:"ruleSetVersion,omitempty"`
+ // RuleGroups - The rule groups of the web application firewall rule set.
+ RuleGroups *[]ApplicationGatewayFirewallRuleGroup `json:"ruleGroups,omitempty"`
+}
+
+// ApplicationGatewayFrontendIPConfiguration frontend IP configuration of an application gateway.
+type ApplicationGatewayFrontendIPConfiguration struct {
+ *ApplicationGatewayFrontendIPConfigurationPropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayFrontendIPConfiguration.
+func (agfic ApplicationGatewayFrontendIPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agfic.ApplicationGatewayFrontendIPConfigurationPropertiesFormat != nil {
+ objectMap["properties"] = agfic.ApplicationGatewayFrontendIPConfigurationPropertiesFormat
+ }
+ if agfic.Name != nil {
+ objectMap["name"] = agfic.Name
+ }
+ if agfic.Etag != nil {
+ objectMap["etag"] = agfic.Etag
+ }
+ if agfic.Type != nil {
+ objectMap["type"] = agfic.Type
+ }
+ if agfic.ID != nil {
+ objectMap["id"] = agfic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayFrontendIPConfiguration struct.
+func (agfic *ApplicationGatewayFrontendIPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayFrontendIPConfigurationPropertiesFormat ApplicationGatewayFrontendIPConfigurationPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayFrontendIPConfigurationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agfic.ApplicationGatewayFrontendIPConfigurationPropertiesFormat = &applicationGatewayFrontendIPConfigurationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agfic.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agfic.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agfic.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agfic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayFrontendIPConfigurationPropertiesFormat properties of Frontend IP configuration of an
+// application gateway.
+type ApplicationGatewayFrontendIPConfigurationPropertiesFormat struct {
+ // PrivateIPAddress - PrivateIPAddress of the network interface IP Configuration.
+ PrivateIPAddress *string `json:"privateIPAddress,omitempty"`
+ // PrivateIPAllocationMethod - PrivateIP allocation method. Possible values include: 'Static', 'Dynamic'
+ PrivateIPAllocationMethod IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
+ // Subnet - Reference of the subnet resource.
+ Subnet *SubResource `json:"subnet,omitempty"`
+ // PublicIPAddress - Reference of the PublicIP resource.
+ PublicIPAddress *SubResource `json:"publicIPAddress,omitempty"`
+ // ProvisioningState - Provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayFrontendPort frontend port of an application gateway.
+type ApplicationGatewayFrontendPort struct {
+ *ApplicationGatewayFrontendPortPropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayFrontendPort.
+func (agfp ApplicationGatewayFrontendPort) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agfp.ApplicationGatewayFrontendPortPropertiesFormat != nil {
+ objectMap["properties"] = agfp.ApplicationGatewayFrontendPortPropertiesFormat
+ }
+ if agfp.Name != nil {
+ objectMap["name"] = agfp.Name
+ }
+ if agfp.Etag != nil {
+ objectMap["etag"] = agfp.Etag
+ }
+ if agfp.Type != nil {
+ objectMap["type"] = agfp.Type
+ }
+ if agfp.ID != nil {
+ objectMap["id"] = agfp.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayFrontendPort struct.
+func (agfp *ApplicationGatewayFrontendPort) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayFrontendPortPropertiesFormat ApplicationGatewayFrontendPortPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayFrontendPortPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agfp.ApplicationGatewayFrontendPortPropertiesFormat = &applicationGatewayFrontendPortPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agfp.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agfp.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agfp.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agfp.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayFrontendPortPropertiesFormat properties of Frontend port of an application gateway.
+type ApplicationGatewayFrontendPortPropertiesFormat struct {
+ // Port - Frontend port
+ Port *int32 `json:"port,omitempty"`
+ // ProvisioningState - Provisioning state of the frontend port resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayHTTPListener http listener of an application gateway.
+type ApplicationGatewayHTTPListener struct {
+ *ApplicationGatewayHTTPListenerPropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayHTTPListener.
+func (aghl ApplicationGatewayHTTPListener) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if aghl.ApplicationGatewayHTTPListenerPropertiesFormat != nil {
+ objectMap["properties"] = aghl.ApplicationGatewayHTTPListenerPropertiesFormat
+ }
+ if aghl.Name != nil {
+ objectMap["name"] = aghl.Name
+ }
+ if aghl.Etag != nil {
+ objectMap["etag"] = aghl.Etag
+ }
+ if aghl.Type != nil {
+ objectMap["type"] = aghl.Type
+ }
+ if aghl.ID != nil {
+ objectMap["id"] = aghl.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayHTTPListener struct.
+func (aghl *ApplicationGatewayHTTPListener) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayHTTPListenerPropertiesFormat ApplicationGatewayHTTPListenerPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayHTTPListenerPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ aghl.ApplicationGatewayHTTPListenerPropertiesFormat = &applicationGatewayHTTPListenerPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ aghl.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ aghl.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ aghl.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ aghl.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayHTTPListenerPropertiesFormat properties of HTTP listener of an application gateway.
+type ApplicationGatewayHTTPListenerPropertiesFormat struct {
+ // FrontendIPConfiguration - Frontend IP configuration resource of an application gateway.
+ FrontendIPConfiguration *SubResource `json:"frontendIPConfiguration,omitempty"`
+ // FrontendPort - Frontend port resource of an application gateway.
+ FrontendPort *SubResource `json:"frontendPort,omitempty"`
+ // Protocol - Protocol. Possible values include: 'HTTP', 'HTTPS'
+ Protocol ApplicationGatewayProtocol `json:"protocol,omitempty"`
+ // HostName - Host name of HTTP listener.
+ HostName *string `json:"hostName,omitempty"`
+ // SslCertificate - SSL certificate resource of an application gateway.
+ SslCertificate *SubResource `json:"sslCertificate,omitempty"`
+ // RequireServerNameIndication - Applicable only if protocol is https. Enables SNI for multi-hosting.
+ RequireServerNameIndication *bool `json:"requireServerNameIndication,omitempty"`
+ // ProvisioningState - Provisioning state of the HTTP listener resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayIPConfiguration IP configuration of an application gateway. Currently 1 public and 1
+// private IP configuration is allowed.
+type ApplicationGatewayIPConfiguration struct {
+ *ApplicationGatewayIPConfigurationPropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayIPConfiguration.
+func (agic ApplicationGatewayIPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agic.ApplicationGatewayIPConfigurationPropertiesFormat != nil {
+ objectMap["properties"] = agic.ApplicationGatewayIPConfigurationPropertiesFormat
+ }
+ if agic.Name != nil {
+ objectMap["name"] = agic.Name
+ }
+ if agic.Etag != nil {
+ objectMap["etag"] = agic.Etag
+ }
+ if agic.Type != nil {
+ objectMap["type"] = agic.Type
+ }
+ if agic.ID != nil {
+ objectMap["id"] = agic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayIPConfiguration struct.
+func (agic *ApplicationGatewayIPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayIPConfigurationPropertiesFormat ApplicationGatewayIPConfigurationPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayIPConfigurationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agic.ApplicationGatewayIPConfigurationPropertiesFormat = &applicationGatewayIPConfigurationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agic.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agic.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agic.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayIPConfigurationPropertiesFormat properties of IP configuration of an application
+// gateway.
+type ApplicationGatewayIPConfigurationPropertiesFormat struct {
+ // Subnet - Reference of the subnet resource. A subnet from where application gateway gets its private address.
+ Subnet *SubResource `json:"subnet,omitempty"`
+ // ProvisioningState - Provisioning state of the application gateway subnet resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayListResult response for ListApplicationGateways API service call.
+type ApplicationGatewayListResult struct {
+ autorest.Response `json:"-"`
+ // Value - List of an application gateways in a resource group.
+ Value *[]ApplicationGateway `json:"value,omitempty"`
+ // NextLink - URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ApplicationGatewayListResultIterator provides access to a complete listing of ApplicationGateway values.
+type ApplicationGatewayListResultIterator struct {
+ i int
+ page ApplicationGatewayListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ApplicationGatewayListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewayListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ApplicationGatewayListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ApplicationGatewayListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ApplicationGatewayListResultIterator) Response() ApplicationGatewayListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ApplicationGatewayListResultIterator) Value() ApplicationGateway {
+ if !iter.page.NotDone() {
+ return ApplicationGateway{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ApplicationGatewayListResultIterator type.
+func NewApplicationGatewayListResultIterator(page ApplicationGatewayListResultPage) ApplicationGatewayListResultIterator {
+ return ApplicationGatewayListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (aglr ApplicationGatewayListResult) IsEmpty() bool {
+ return aglr.Value == nil || len(*aglr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (aglr ApplicationGatewayListResult) hasNextLink() bool {
+ return aglr.NextLink != nil && len(*aglr.NextLink) != 0
+}
+
+// applicationGatewayListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (aglr ApplicationGatewayListResult) applicationGatewayListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !aglr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(aglr.NextLink)))
+}
+
+// ApplicationGatewayListResultPage contains a page of ApplicationGateway values.
+type ApplicationGatewayListResultPage struct {
+ fn func(context.Context, ApplicationGatewayListResult) (ApplicationGatewayListResult, error)
+ aglr ApplicationGatewayListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ApplicationGatewayListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationGatewayListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.aglr)
+ if err != nil {
+ return err
+ }
+ page.aglr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ApplicationGatewayListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ApplicationGatewayListResultPage) NotDone() bool {
+ return !page.aglr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ApplicationGatewayListResultPage) Response() ApplicationGatewayListResult {
+ return page.aglr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ApplicationGatewayListResultPage) Values() []ApplicationGateway {
+ if page.aglr.IsEmpty() {
+ return nil
+ }
+ return *page.aglr.Value
+}
+
+// Creates a new instance of the ApplicationGatewayListResultPage type.
+func NewApplicationGatewayListResultPage(cur ApplicationGatewayListResult, getNextPage func(context.Context, ApplicationGatewayListResult) (ApplicationGatewayListResult, error)) ApplicationGatewayListResultPage {
+ return ApplicationGatewayListResultPage{
+ fn: getNextPage,
+ aglr: cur,
+ }
+}
+
+// ApplicationGatewayPathRule path rule of URL path map of an application gateway.
+type ApplicationGatewayPathRule struct {
+ *ApplicationGatewayPathRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayPathRule.
+func (agpr ApplicationGatewayPathRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agpr.ApplicationGatewayPathRulePropertiesFormat != nil {
+ objectMap["properties"] = agpr.ApplicationGatewayPathRulePropertiesFormat
+ }
+ if agpr.Name != nil {
+ objectMap["name"] = agpr.Name
+ }
+ if agpr.Etag != nil {
+ objectMap["etag"] = agpr.Etag
+ }
+ if agpr.Type != nil {
+ objectMap["type"] = agpr.Type
+ }
+ if agpr.ID != nil {
+ objectMap["id"] = agpr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayPathRule struct.
+func (agpr *ApplicationGatewayPathRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayPathRulePropertiesFormat ApplicationGatewayPathRulePropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayPathRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agpr.ApplicationGatewayPathRulePropertiesFormat = &applicationGatewayPathRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agpr.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agpr.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agpr.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agpr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayPathRulePropertiesFormat properties of path rule of an application gateway.
+type ApplicationGatewayPathRulePropertiesFormat struct {
+ // Paths - Path rules of URL path map.
+ Paths *[]string `json:"paths,omitempty"`
+ // BackendAddressPool - Backend address pool resource of URL path map path rule.
+ BackendAddressPool *SubResource `json:"backendAddressPool,omitempty"`
+ // BackendHTTPSettings - Backend http settings resource of URL path map path rule.
+ BackendHTTPSettings *SubResource `json:"backendHttpSettings,omitempty"`
+ // RedirectConfiguration - Redirect configuration resource of URL path map path rule.
+ RedirectConfiguration *SubResource `json:"redirectConfiguration,omitempty"`
+ // ProvisioningState - Path rule of URL path map resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayProbe probe of the application gateway.
+type ApplicationGatewayProbe struct {
+ *ApplicationGatewayProbePropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayProbe.
+func (agp ApplicationGatewayProbe) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agp.ApplicationGatewayProbePropertiesFormat != nil {
+ objectMap["properties"] = agp.ApplicationGatewayProbePropertiesFormat
+ }
+ if agp.Name != nil {
+ objectMap["name"] = agp.Name
+ }
+ if agp.Etag != nil {
+ objectMap["etag"] = agp.Etag
+ }
+ if agp.Type != nil {
+ objectMap["type"] = agp.Type
+ }
+ if agp.ID != nil {
+ objectMap["id"] = agp.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayProbe struct.
+func (agp *ApplicationGatewayProbe) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayProbePropertiesFormat ApplicationGatewayProbePropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayProbePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agp.ApplicationGatewayProbePropertiesFormat = &applicationGatewayProbePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agp.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agp.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agp.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agp.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayProbeHealthResponseMatch application gateway probe health response match
+type ApplicationGatewayProbeHealthResponseMatch struct {
+ // Body - Body that must be contained in the health response. Default value is empty.
+ Body *string `json:"body,omitempty"`
+ // StatusCodes - Allowed ranges of healthy status codes. Default range of healthy status codes is 200-399.
+ StatusCodes *[]string `json:"statusCodes,omitempty"`
+}
+
+// ApplicationGatewayProbePropertiesFormat properties of probe of an application gateway.
+type ApplicationGatewayProbePropertiesFormat struct {
+ // Protocol - Protocol. Possible values include: 'HTTP', 'HTTPS'
+ Protocol ApplicationGatewayProtocol `json:"protocol,omitempty"`
+ // Host - Host name to send the probe to.
+ Host *string `json:"host,omitempty"`
+ // Path - Relative path of probe. Valid path starts from '/'. Probe is sent to ://:
+ Path *string `json:"path,omitempty"`
+ // Interval - The probing interval in seconds. This is the time interval between two consecutive probes. Acceptable values are from 1 second to 86400 seconds.
+ Interval *int32 `json:"interval,omitempty"`
+ // Timeout - the probe timeout in seconds. Probe marked as failed if valid response is not received with this timeout period. Acceptable values are from 1 second to 86400 seconds.
+ Timeout *int32 `json:"timeout,omitempty"`
+ // UnhealthyThreshold - The probe retry count. Backend server is marked down after consecutive probe failure count reaches UnhealthyThreshold. Acceptable values are from 1 second to 20.
+ UnhealthyThreshold *int32 `json:"unhealthyThreshold,omitempty"`
+ // PickHostNameFromBackendHTTPSettings - Whether the host header should be picked from the backend http settings. Default value is false.
+ PickHostNameFromBackendHTTPSettings *bool `json:"pickHostNameFromBackendHttpSettings,omitempty"`
+ // MinServers - Minimum number of servers that are always marked healthy. Default value is 0.
+ MinServers *int32 `json:"minServers,omitempty"`
+ // Match - Criterion for classifying a healthy probe response.
+ Match *ApplicationGatewayProbeHealthResponseMatch `json:"match,omitempty"`
+ // ProvisioningState - Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayPropertiesFormat properties of the application gateway.
+type ApplicationGatewayPropertiesFormat struct {
+ // Sku - SKU of the application gateway resource.
+ Sku *ApplicationGatewaySku `json:"sku,omitempty"`
+ // SslPolicy - SSL policy of the application gateway resource.
+ SslPolicy *ApplicationGatewaySslPolicy `json:"sslPolicy,omitempty"`
+ // OperationalState - READ-ONLY; Operational state of the application gateway resource. Possible values include: 'Stopped', 'Starting', 'Running', 'Stopping'
+ OperationalState ApplicationGatewayOperationalState `json:"operationalState,omitempty"`
+ // GatewayIPConfigurations - Subnets of application the gateway resource.
+ GatewayIPConfigurations *[]ApplicationGatewayIPConfiguration `json:"gatewayIPConfigurations,omitempty"`
+ // AuthenticationCertificates - Authentication certificates of the application gateway resource.
+ AuthenticationCertificates *[]ApplicationGatewayAuthenticationCertificate `json:"authenticationCertificates,omitempty"`
+ // SslCertificates - SSL certificates of the application gateway resource.
+ SslCertificates *[]ApplicationGatewaySslCertificate `json:"sslCertificates,omitempty"`
+ // FrontendIPConfigurations - Frontend IP addresses of the application gateway resource.
+ FrontendIPConfigurations *[]ApplicationGatewayFrontendIPConfiguration `json:"frontendIPConfigurations,omitempty"`
+ // FrontendPorts - Frontend ports of the application gateway resource.
+ FrontendPorts *[]ApplicationGatewayFrontendPort `json:"frontendPorts,omitempty"`
+ // Probes - Probes of the application gateway resource.
+ Probes *[]ApplicationGatewayProbe `json:"probes,omitempty"`
+ // BackendAddressPools - Backend address pool of the application gateway resource.
+ BackendAddressPools *[]ApplicationGatewayBackendAddressPool `json:"backendAddressPools,omitempty"`
+ // BackendHTTPSettingsCollection - Backend http settings of the application gateway resource.
+ BackendHTTPSettingsCollection *[]ApplicationGatewayBackendHTTPSettings `json:"backendHttpSettingsCollection,omitempty"`
+ // HTTPListeners - Http listeners of the application gateway resource.
+ HTTPListeners *[]ApplicationGatewayHTTPListener `json:"httpListeners,omitempty"`
+ // URLPathMaps - URL path map of the application gateway resource.
+ URLPathMaps *[]ApplicationGatewayURLPathMap `json:"urlPathMaps,omitempty"`
+ // RequestRoutingRules - Request routing rules of the application gateway resource.
+ RequestRoutingRules *[]ApplicationGatewayRequestRoutingRule `json:"requestRoutingRules,omitempty"`
+ // RedirectConfigurations - Redirect configurations of the application gateway resource.
+ RedirectConfigurations *[]ApplicationGatewayRedirectConfiguration `json:"redirectConfigurations,omitempty"`
+ // WebApplicationFirewallConfiguration - Web application firewall configuration.
+ WebApplicationFirewallConfiguration *ApplicationGatewayWebApplicationFirewallConfiguration `json:"webApplicationFirewallConfiguration,omitempty"`
+ // EnableHTTP2 - Whether HTTP2 is enabled on the application gateway resource.
+ EnableHTTP2 *bool `json:"enableHttp2,omitempty"`
+ // ResourceGUID - Resource GUID property of the application gateway resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - Provisioning state of the application gateway resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayPropertiesFormat.
+func (agpf ApplicationGatewayPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agpf.Sku != nil {
+ objectMap["sku"] = agpf.Sku
+ }
+ if agpf.SslPolicy != nil {
+ objectMap["sslPolicy"] = agpf.SslPolicy
+ }
+ if agpf.GatewayIPConfigurations != nil {
+ objectMap["gatewayIPConfigurations"] = agpf.GatewayIPConfigurations
+ }
+ if agpf.AuthenticationCertificates != nil {
+ objectMap["authenticationCertificates"] = agpf.AuthenticationCertificates
+ }
+ if agpf.SslCertificates != nil {
+ objectMap["sslCertificates"] = agpf.SslCertificates
+ }
+ if agpf.FrontendIPConfigurations != nil {
+ objectMap["frontendIPConfigurations"] = agpf.FrontendIPConfigurations
+ }
+ if agpf.FrontendPorts != nil {
+ objectMap["frontendPorts"] = agpf.FrontendPorts
+ }
+ if agpf.Probes != nil {
+ objectMap["probes"] = agpf.Probes
+ }
+ if agpf.BackendAddressPools != nil {
+ objectMap["backendAddressPools"] = agpf.BackendAddressPools
+ }
+ if agpf.BackendHTTPSettingsCollection != nil {
+ objectMap["backendHttpSettingsCollection"] = agpf.BackendHTTPSettingsCollection
+ }
+ if agpf.HTTPListeners != nil {
+ objectMap["httpListeners"] = agpf.HTTPListeners
+ }
+ if agpf.URLPathMaps != nil {
+ objectMap["urlPathMaps"] = agpf.URLPathMaps
+ }
+ if agpf.RequestRoutingRules != nil {
+ objectMap["requestRoutingRules"] = agpf.RequestRoutingRules
+ }
+ if agpf.RedirectConfigurations != nil {
+ objectMap["redirectConfigurations"] = agpf.RedirectConfigurations
+ }
+ if agpf.WebApplicationFirewallConfiguration != nil {
+ objectMap["webApplicationFirewallConfiguration"] = agpf.WebApplicationFirewallConfiguration
+ }
+ if agpf.EnableHTTP2 != nil {
+ objectMap["enableHttp2"] = agpf.EnableHTTP2
+ }
+ if agpf.ResourceGUID != nil {
+ objectMap["resourceGuid"] = agpf.ResourceGUID
+ }
+ if agpf.ProvisioningState != nil {
+ objectMap["provisioningState"] = agpf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// ApplicationGatewayRedirectConfiguration redirect configuration of an application gateway.
+type ApplicationGatewayRedirectConfiguration struct {
+ *ApplicationGatewayRedirectConfigurationPropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayRedirectConfiguration.
+func (agrc ApplicationGatewayRedirectConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agrc.ApplicationGatewayRedirectConfigurationPropertiesFormat != nil {
+ objectMap["properties"] = agrc.ApplicationGatewayRedirectConfigurationPropertiesFormat
+ }
+ if agrc.Name != nil {
+ objectMap["name"] = agrc.Name
+ }
+ if agrc.Etag != nil {
+ objectMap["etag"] = agrc.Etag
+ }
+ if agrc.Type != nil {
+ objectMap["type"] = agrc.Type
+ }
+ if agrc.ID != nil {
+ objectMap["id"] = agrc.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayRedirectConfiguration struct.
+func (agrc *ApplicationGatewayRedirectConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayRedirectConfigurationPropertiesFormat ApplicationGatewayRedirectConfigurationPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayRedirectConfigurationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agrc.ApplicationGatewayRedirectConfigurationPropertiesFormat = &applicationGatewayRedirectConfigurationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agrc.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agrc.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agrc.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agrc.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayRedirectConfigurationPropertiesFormat properties of redirect configuration of the
+// application gateway.
+type ApplicationGatewayRedirectConfigurationPropertiesFormat struct {
+ // RedirectType - Supported http redirection types - Permanent, Temporary, Found, SeeOther. Possible values include: 'Permanent', 'Found', 'SeeOther', 'Temporary'
+ RedirectType ApplicationGatewayRedirectType `json:"redirectType,omitempty"`
+ // TargetListener - Reference to a listener to redirect the request to.
+ TargetListener *SubResource `json:"targetListener,omitempty"`
+ // TargetURL - Url to redirect the request to.
+ TargetURL *string `json:"targetUrl,omitempty"`
+ // IncludePath - Include path in the redirected url.
+ IncludePath *bool `json:"includePath,omitempty"`
+ // IncludeQueryString - Include query string in the redirected url.
+ IncludeQueryString *bool `json:"includeQueryString,omitempty"`
+ // RequestRoutingRules - Request routing specifying redirect configuration.
+ RequestRoutingRules *[]SubResource `json:"requestRoutingRules,omitempty"`
+ // URLPathMaps - Url path maps specifying default redirect configuration.
+ URLPathMaps *[]SubResource `json:"urlPathMaps,omitempty"`
+ // PathRules - Path rules specifying redirect configuration.
+ PathRules *[]SubResource `json:"pathRules,omitempty"`
+}
+
+// ApplicationGatewayRequestRoutingRule request routing rule of an application gateway.
+type ApplicationGatewayRequestRoutingRule struct {
+ *ApplicationGatewayRequestRoutingRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayRequestRoutingRule.
+func (agrrr ApplicationGatewayRequestRoutingRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agrrr.ApplicationGatewayRequestRoutingRulePropertiesFormat != nil {
+ objectMap["properties"] = agrrr.ApplicationGatewayRequestRoutingRulePropertiesFormat
+ }
+ if agrrr.Name != nil {
+ objectMap["name"] = agrrr.Name
+ }
+ if agrrr.Etag != nil {
+ objectMap["etag"] = agrrr.Etag
+ }
+ if agrrr.Type != nil {
+ objectMap["type"] = agrrr.Type
+ }
+ if agrrr.ID != nil {
+ objectMap["id"] = agrrr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayRequestRoutingRule struct.
+func (agrrr *ApplicationGatewayRequestRoutingRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayRequestRoutingRulePropertiesFormat ApplicationGatewayRequestRoutingRulePropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayRequestRoutingRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agrrr.ApplicationGatewayRequestRoutingRulePropertiesFormat = &applicationGatewayRequestRoutingRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agrrr.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agrrr.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agrrr.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agrrr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayRequestRoutingRulePropertiesFormat properties of request routing rule of the
+// application gateway.
+type ApplicationGatewayRequestRoutingRulePropertiesFormat struct {
+ // RuleType - Rule type. Possible values include: 'Basic', 'PathBasedRouting'
+ RuleType ApplicationGatewayRequestRoutingRuleType `json:"ruleType,omitempty"`
+ // BackendAddressPool - Backend address pool resource of the application gateway.
+ BackendAddressPool *SubResource `json:"backendAddressPool,omitempty"`
+ // BackendHTTPSettings - Frontend port resource of the application gateway.
+ BackendHTTPSettings *SubResource `json:"backendHttpSettings,omitempty"`
+ // HTTPListener - Http listener resource of the application gateway.
+ HTTPListener *SubResource `json:"httpListener,omitempty"`
+ // URLPathMap - URL path map resource of the application gateway.
+ URLPathMap *SubResource `json:"urlPathMap,omitempty"`
+ // RedirectConfiguration - Redirect configuration resource of the application gateway.
+ RedirectConfiguration *SubResource `json:"redirectConfiguration,omitempty"`
+ // ProvisioningState - Provisioning state of the request routing rule resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewaysBackendHealthFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ApplicationGatewaysBackendHealthFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationGatewaysClient) (ApplicationGatewayBackendHealth, error)
+}
+
+// ApplicationGatewaysCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ApplicationGatewaysCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationGatewaysClient) (ApplicationGateway, error)
+}
+
+// ApplicationGatewaysDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ApplicationGatewaysDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationGatewaysClient) (autorest.Response, error)
+}
+
+// ApplicationGatewaySku SKU of an application gateway
+type ApplicationGatewaySku struct {
+ // Name - Name of an application gateway SKU. Possible values include: 'StandardSmall', 'StandardMedium', 'StandardLarge', 'WAFMedium', 'WAFLarge'
+ Name ApplicationGatewaySkuName `json:"name,omitempty"`
+ // Tier - Tier of an application gateway. Possible values include: 'Standard', 'WAF'
+ Tier ApplicationGatewayTier `json:"tier,omitempty"`
+ // Capacity - Capacity (instance count) of an application gateway.
+ Capacity *int32 `json:"capacity,omitempty"`
+}
+
+// ApplicationGatewaySslCertificate SSL certificates of an application gateway.
+type ApplicationGatewaySslCertificate struct {
+ *ApplicationGatewaySslCertificatePropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewaySslCertificate.
+func (agsc ApplicationGatewaySslCertificate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agsc.ApplicationGatewaySslCertificatePropertiesFormat != nil {
+ objectMap["properties"] = agsc.ApplicationGatewaySslCertificatePropertiesFormat
+ }
+ if agsc.Name != nil {
+ objectMap["name"] = agsc.Name
+ }
+ if agsc.Etag != nil {
+ objectMap["etag"] = agsc.Etag
+ }
+ if agsc.Type != nil {
+ objectMap["type"] = agsc.Type
+ }
+ if agsc.ID != nil {
+ objectMap["id"] = agsc.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewaySslCertificate struct.
+func (agsc *ApplicationGatewaySslCertificate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewaySslCertificatePropertiesFormat ApplicationGatewaySslCertificatePropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewaySslCertificatePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agsc.ApplicationGatewaySslCertificatePropertiesFormat = &applicationGatewaySslCertificatePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agsc.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agsc.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agsc.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agsc.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewaySslCertificatePropertiesFormat properties of SSL certificates of an application
+// gateway.
+type ApplicationGatewaySslCertificatePropertiesFormat struct {
+ // Data - Base-64 encoded pfx certificate. Only applicable in PUT Request.
+ Data *string `json:"data,omitempty"`
+ // Password - Password for the pfx file specified in data. Only applicable in PUT request.
+ Password *string `json:"password,omitempty"`
+ // PublicCertData - Base-64 encoded Public cert data corresponding to pfx specified in data. Only applicable in GET request.
+ PublicCertData *string `json:"publicCertData,omitempty"`
+ // ProvisioningState - Provisioning state of the SSL certificate resource Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewaySslPolicy application Gateway Ssl policy.
+type ApplicationGatewaySslPolicy struct {
+ // DisabledSslProtocols - Ssl protocols to be disabled on application gateway.
+ DisabledSslProtocols *[]ApplicationGatewaySslProtocol `json:"disabledSslProtocols,omitempty"`
+ // PolicyType - Type of Ssl Policy. Possible values include: 'Predefined', 'Custom'
+ PolicyType ApplicationGatewaySslPolicyType `json:"policyType,omitempty"`
+ // PolicyName - Name of Ssl predefined policy. Possible values include: 'AppGwSslPolicy20150501', 'AppGwSslPolicy20170401', 'AppGwSslPolicy20170401S'
+ PolicyName ApplicationGatewaySslPolicyName `json:"policyName,omitempty"`
+ // CipherSuites - Ssl cipher suites to be enabled in the specified order to application gateway.
+ CipherSuites *[]ApplicationGatewaySslCipherSuite `json:"cipherSuites,omitempty"`
+ // MinProtocolVersion - Minimum version of Ssl protocol to be supported on application gateway. Possible values include: 'TLSv10', 'TLSv11', 'TLSv12'
+ MinProtocolVersion ApplicationGatewaySslProtocol `json:"minProtocolVersion,omitempty"`
+}
+
+// ApplicationGatewaySslPredefinedPolicy an Ssl predefined policy
+type ApplicationGatewaySslPredefinedPolicy struct {
+ autorest.Response `json:"-"`
+ // Name - Name of Ssl predefined policy.
+ Name *string `json:"name,omitempty"`
+ *ApplicationGatewaySslPredefinedPolicyPropertiesFormat `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewaySslPredefinedPolicy.
+func (agspp ApplicationGatewaySslPredefinedPolicy) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agspp.Name != nil {
+ objectMap["name"] = agspp.Name
+ }
+ if agspp.ApplicationGatewaySslPredefinedPolicyPropertiesFormat != nil {
+ objectMap["properties"] = agspp.ApplicationGatewaySslPredefinedPolicyPropertiesFormat
+ }
+ if agspp.ID != nil {
+ objectMap["id"] = agspp.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewaySslPredefinedPolicy struct.
+func (agspp *ApplicationGatewaySslPredefinedPolicy) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agspp.Name = &name
+ }
+ case "properties":
+ if v != nil {
+ var applicationGatewaySslPredefinedPolicyPropertiesFormat ApplicationGatewaySslPredefinedPolicyPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewaySslPredefinedPolicyPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agspp.ApplicationGatewaySslPredefinedPolicyPropertiesFormat = &applicationGatewaySslPredefinedPolicyPropertiesFormat
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agspp.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewaySslPredefinedPolicyPropertiesFormat properties of
+// ApplicationGatewaySslPredefinedPolicy
+type ApplicationGatewaySslPredefinedPolicyPropertiesFormat struct {
+ // CipherSuites - Ssl cipher suites to be enabled in the specified order for application gateway.
+ CipherSuites *[]ApplicationGatewaySslCipherSuite `json:"cipherSuites,omitempty"`
+ // MinProtocolVersion - Minimum version of Ssl protocol to be supported on application gateway. Possible values include: 'TLSv10', 'TLSv11', 'TLSv12'
+ MinProtocolVersion ApplicationGatewaySslProtocol `json:"minProtocolVersion,omitempty"`
+}
+
+// ApplicationGatewaysStartFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ApplicationGatewaysStartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationGatewaysClient) (autorest.Response, error)
+}
+
+// ApplicationGatewaysStopFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type ApplicationGatewaysStopFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationGatewaysClient) (autorest.Response, error)
+}
+
+// ApplicationGatewaysUpdateTagsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ApplicationGatewaysUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationGatewaysClient) (ApplicationGateway, error)
+}
+
+// ApplicationGatewayURLPathMap urlPathMaps give a url path to the backend mapping information for
+// PathBasedRouting.
+type ApplicationGatewayURLPathMap struct {
+ *ApplicationGatewayURLPathMapPropertiesFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - Type of the resource.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationGatewayURLPathMap.
+func (agupm ApplicationGatewayURLPathMap) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if agupm.ApplicationGatewayURLPathMapPropertiesFormat != nil {
+ objectMap["properties"] = agupm.ApplicationGatewayURLPathMapPropertiesFormat
+ }
+ if agupm.Name != nil {
+ objectMap["name"] = agupm.Name
+ }
+ if agupm.Etag != nil {
+ objectMap["etag"] = agupm.Etag
+ }
+ if agupm.Type != nil {
+ objectMap["type"] = agupm.Type
+ }
+ if agupm.ID != nil {
+ objectMap["id"] = agupm.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationGatewayURLPathMap struct.
+func (agupm *ApplicationGatewayURLPathMap) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationGatewayURLPathMapPropertiesFormat ApplicationGatewayURLPathMapPropertiesFormat
+ err = json.Unmarshal(*v, &applicationGatewayURLPathMapPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ agupm.ApplicationGatewayURLPathMapPropertiesFormat = &applicationGatewayURLPathMapPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ agupm.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ agupm.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ agupm.Type = &typeVar
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ agupm.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationGatewayURLPathMapPropertiesFormat properties of UrlPathMap of the application gateway.
+type ApplicationGatewayURLPathMapPropertiesFormat struct {
+ // DefaultBackendAddressPool - Default backend address pool resource of URL path map.
+ DefaultBackendAddressPool *SubResource `json:"defaultBackendAddressPool,omitempty"`
+ // DefaultBackendHTTPSettings - Default backend http settings resource of URL path map.
+ DefaultBackendHTTPSettings *SubResource `json:"defaultBackendHttpSettings,omitempty"`
+ // DefaultRedirectConfiguration - Default redirect configuration resource of URL path map.
+ DefaultRedirectConfiguration *SubResource `json:"defaultRedirectConfiguration,omitempty"`
+ // PathRules - Path rule of URL path map resource.
+ PathRules *[]ApplicationGatewayPathRule `json:"pathRules,omitempty"`
+ // ProvisioningState - Provisioning state of the backend http settings resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationGatewayWebApplicationFirewallConfiguration application gateway web application firewall
+// configuration.
+type ApplicationGatewayWebApplicationFirewallConfiguration struct {
+ // Enabled - Whether the web application firewall is enabled or not.
+ Enabled *bool `json:"enabled,omitempty"`
+ // FirewallMode - Web application firewall mode. Possible values include: 'Detection', 'Prevention'
+ FirewallMode ApplicationGatewayFirewallMode `json:"firewallMode,omitempty"`
+ // RuleSetType - The type of the web application firewall rule set. Possible values are: 'OWASP'.
+ RuleSetType *string `json:"ruleSetType,omitempty"`
+ // RuleSetVersion - The version of the rule set type.
+ RuleSetVersion *string `json:"ruleSetVersion,omitempty"`
+ // DisabledRuleGroups - The disabled rule groups.
+ DisabledRuleGroups *[]ApplicationGatewayFirewallDisabledRuleGroup `json:"disabledRuleGroups,omitempty"`
+}
+
+// ApplicationSecurityGroup an application security group in a resource group.
+type ApplicationSecurityGroup struct {
+ autorest.Response `json:"-"`
+ // ApplicationSecurityGroupPropertiesFormat - Properties of the application security group.
+ *ApplicationSecurityGroupPropertiesFormat `json:"properties,omitempty"`
+ // Etag - READ-ONLY; A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationSecurityGroup.
+func (asg ApplicationSecurityGroup) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if asg.ApplicationSecurityGroupPropertiesFormat != nil {
+ objectMap["properties"] = asg.ApplicationSecurityGroupPropertiesFormat
+ }
+ if asg.ID != nil {
+ objectMap["id"] = asg.ID
+ }
+ if asg.Location != nil {
+ objectMap["location"] = asg.Location
+ }
+ if asg.Tags != nil {
+ objectMap["tags"] = asg.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ApplicationSecurityGroup struct.
+func (asg *ApplicationSecurityGroup) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var applicationSecurityGroupPropertiesFormat ApplicationSecurityGroupPropertiesFormat
+ err = json.Unmarshal(*v, &applicationSecurityGroupPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ asg.ApplicationSecurityGroupPropertiesFormat = &applicationSecurityGroupPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ asg.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ asg.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ asg.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ asg.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ asg.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ asg.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// ApplicationSecurityGroupListResult a list of application security groups.
+type ApplicationSecurityGroupListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of application security groups.
+ Value *[]ApplicationSecurityGroup `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ApplicationSecurityGroupListResult.
+func (asglr ApplicationSecurityGroupListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if asglr.Value != nil {
+ objectMap["value"] = asglr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// ApplicationSecurityGroupListResultIterator provides access to a complete listing of
+// ApplicationSecurityGroup values.
+type ApplicationSecurityGroupListResultIterator struct {
+ i int
+ page ApplicationSecurityGroupListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ApplicationSecurityGroupListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ApplicationSecurityGroupListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ApplicationSecurityGroupListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ApplicationSecurityGroupListResultIterator) Response() ApplicationSecurityGroupListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ApplicationSecurityGroupListResultIterator) Value() ApplicationSecurityGroup {
+ if !iter.page.NotDone() {
+ return ApplicationSecurityGroup{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ApplicationSecurityGroupListResultIterator type.
+func NewApplicationSecurityGroupListResultIterator(page ApplicationSecurityGroupListResultPage) ApplicationSecurityGroupListResultIterator {
+ return ApplicationSecurityGroupListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (asglr ApplicationSecurityGroupListResult) IsEmpty() bool {
+ return asglr.Value == nil || len(*asglr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (asglr ApplicationSecurityGroupListResult) hasNextLink() bool {
+ return asglr.NextLink != nil && len(*asglr.NextLink) != 0
+}
+
+// applicationSecurityGroupListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (asglr ApplicationSecurityGroupListResult) applicationSecurityGroupListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !asglr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(asglr.NextLink)))
+}
+
+// ApplicationSecurityGroupListResultPage contains a page of ApplicationSecurityGroup values.
+type ApplicationSecurityGroupListResultPage struct {
+ fn func(context.Context, ApplicationSecurityGroupListResult) (ApplicationSecurityGroupListResult, error)
+ asglr ApplicationSecurityGroupListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ApplicationSecurityGroupListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ApplicationSecurityGroupListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.asglr)
+ if err != nil {
+ return err
+ }
+ page.asglr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ApplicationSecurityGroupListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ApplicationSecurityGroupListResultPage) NotDone() bool {
+ return !page.asglr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ApplicationSecurityGroupListResultPage) Response() ApplicationSecurityGroupListResult {
+ return page.asglr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ApplicationSecurityGroupListResultPage) Values() []ApplicationSecurityGroup {
+ if page.asglr.IsEmpty() {
+ return nil
+ }
+ return *page.asglr.Value
+}
+
+// Creates a new instance of the ApplicationSecurityGroupListResultPage type.
+func NewApplicationSecurityGroupListResultPage(cur ApplicationSecurityGroupListResult, getNextPage func(context.Context, ApplicationSecurityGroupListResult) (ApplicationSecurityGroupListResult, error)) ApplicationSecurityGroupListResultPage {
+ return ApplicationSecurityGroupListResultPage{
+ fn: getNextPage,
+ asglr: cur,
+ }
+}
+
+// ApplicationSecurityGroupPropertiesFormat application security group properties.
+type ApplicationSecurityGroupPropertiesFormat struct {
+ // ResourceGUID - READ-ONLY; The resource GUID property of the application security group resource. It uniquely identifies a resource, even if the user changes its name or migrate the resource across subscriptions or resource groups.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the application security group resource. Possible values are: 'Succeeded', 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// ApplicationSecurityGroupsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results
+// of a long-running operation.
+type ApplicationSecurityGroupsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationSecurityGroupsClient) (ApplicationSecurityGroup, error)
+}
+
+// ApplicationSecurityGroupsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ApplicationSecurityGroupsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ApplicationSecurityGroupsClient) (autorest.Response, error)
+}
+
+// AuthorizationListResult response for ListAuthorizations API service call retrieves all authorizations
+// that belongs to an ExpressRouteCircuit.
+type AuthorizationListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The authorizations in an ExpressRoute Circuit.
+ Value *[]ExpressRouteCircuitAuthorization `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AuthorizationListResultIterator provides access to a complete listing of
+// ExpressRouteCircuitAuthorization values.
+type AuthorizationListResultIterator struct {
+ i int
+ page AuthorizationListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *AuthorizationListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *AuthorizationListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter AuthorizationListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter AuthorizationListResultIterator) Response() AuthorizationListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter AuthorizationListResultIterator) Value() ExpressRouteCircuitAuthorization {
+ if !iter.page.NotDone() {
+ return ExpressRouteCircuitAuthorization{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the AuthorizationListResultIterator type.
+func NewAuthorizationListResultIterator(page AuthorizationListResultPage) AuthorizationListResultIterator {
+ return AuthorizationListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (alr AuthorizationListResult) IsEmpty() bool {
+ return alr.Value == nil || len(*alr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (alr AuthorizationListResult) hasNextLink() bool {
+ return alr.NextLink != nil && len(*alr.NextLink) != 0
+}
+
+// authorizationListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (alr AuthorizationListResult) authorizationListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !alr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(alr.NextLink)))
+}
+
+// AuthorizationListResultPage contains a page of ExpressRouteCircuitAuthorization values.
+type AuthorizationListResultPage struct {
+ fn func(context.Context, AuthorizationListResult) (AuthorizationListResult, error)
+ alr AuthorizationListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *AuthorizationListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.alr)
+ if err != nil {
+ return err
+ }
+ page.alr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *AuthorizationListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page AuthorizationListResultPage) NotDone() bool {
+ return !page.alr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page AuthorizationListResultPage) Response() AuthorizationListResult {
+ return page.alr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page AuthorizationListResultPage) Values() []ExpressRouteCircuitAuthorization {
+ if page.alr.IsEmpty() {
+ return nil
+ }
+ return *page.alr.Value
+}
+
+// Creates a new instance of the AuthorizationListResultPage type.
+func NewAuthorizationListResultPage(cur AuthorizationListResult, getNextPage func(context.Context, AuthorizationListResult) (AuthorizationListResult, error)) AuthorizationListResultPage {
+ return AuthorizationListResultPage{
+ fn: getNextPage,
+ alr: cur,
+ }
+}
+
+// AuthorizationPropertiesFormat ...
+type AuthorizationPropertiesFormat struct {
+ // AuthorizationKey - The authorization key.
+ AuthorizationKey *string `json:"authorizationKey,omitempty"`
+ // AuthorizationUseStatus - AuthorizationUseStatus. Possible values are: 'Available' and 'InUse'. Possible values include: 'Available', 'InUse'
+ AuthorizationUseStatus AuthorizationUseStatus `json:"authorizationUseStatus,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// Availability availability of the metric.
+type Availability struct {
+ // TimeGrain - The time grain of the availability.
+ TimeGrain *string `json:"timeGrain,omitempty"`
+ // Retention - The retention of the availability.
+ Retention *string `json:"retention,omitempty"`
+ // BlobDuration - Duration of the availability blob.
+ BlobDuration *string `json:"blobDuration,omitempty"`
+}
+
+// AvailableProvidersList list of available countries with details.
+type AvailableProvidersList struct {
+ autorest.Response `json:"-"`
+ // Countries - List of available countries.
+ Countries *[]AvailableProvidersListCountry `json:"countries,omitempty"`
+}
+
+// AvailableProvidersListCity city or town details.
+type AvailableProvidersListCity struct {
+ // CityName - The city or town name.
+ CityName *string `json:"cityName,omitempty"`
+ // Providers - A list of Internet service providers.
+ Providers *[]string `json:"providers,omitempty"`
+}
+
+// AvailableProvidersListCountry country details.
+type AvailableProvidersListCountry struct {
+ // CountryName - The country name.
+ CountryName *string `json:"countryName,omitempty"`
+ // Providers - A list of Internet service providers.
+ Providers *[]string `json:"providers,omitempty"`
+ // States - List of available states in the country.
+ States *[]AvailableProvidersListState `json:"states,omitempty"`
+}
+
+// AvailableProvidersListParameters constraints that determine the list of available Internet service
+// providers.
+type AvailableProvidersListParameters struct {
+ // AzureLocations - A list of Azure regions.
+ AzureLocations *[]string `json:"azureLocations,omitempty"`
+ // Country - The country for available providers list.
+ Country *string `json:"country,omitempty"`
+ // State - The state for available providers list.
+ State *string `json:"state,omitempty"`
+ // City - The city or town for available providers list.
+ City *string `json:"city,omitempty"`
+}
+
+// AvailableProvidersListState state details.
+type AvailableProvidersListState struct {
+ // StateName - The state name.
+ StateName *string `json:"stateName,omitempty"`
+ // Providers - A list of Internet service providers.
+ Providers *[]string `json:"providers,omitempty"`
+ // Cities - List of available cities or towns in the state.
+ Cities *[]AvailableProvidersListCity `json:"cities,omitempty"`
+}
+
+// AzureAsyncOperationResult the response body contains the status of the specified asynchronous operation,
+// indicating whether it has succeeded, is in progress, or has failed. Note that this status is distinct
+// from the HTTP status code returned for the Get Operation Status operation itself. If the asynchronous
+// operation succeeded, the response body includes the HTTP status code for the successful request. If the
+// asynchronous operation failed, the response body includes the HTTP status code for the failed request
+// and error information regarding the failure.
+type AzureAsyncOperationResult struct {
+ // Status - Status of the Azure async operation. Possible values are: 'InProgress', 'Succeeded', and 'Failed'. Possible values include: 'OperationStatusInProgress', 'OperationStatusSucceeded', 'OperationStatusFailed'
+ Status OperationStatus `json:"status,omitempty"`
+ Error *Error `json:"error,omitempty"`
+}
+
+// AzureReachabilityReport azure reachability report details.
+type AzureReachabilityReport struct {
+ autorest.Response `json:"-"`
+ // AggregationLevel - The aggregation level of Azure reachability report. Can be Country, State or City.
+ AggregationLevel *string `json:"aggregationLevel,omitempty"`
+ ProviderLocation *AzureReachabilityReportLocation `json:"providerLocation,omitempty"`
+ // ReachabilityReport - List of Azure reachability report items.
+ ReachabilityReport *[]AzureReachabilityReportItem `json:"reachabilityReport,omitempty"`
+}
+
+// AzureReachabilityReportItem azure reachability report details for a given provider location.
+type AzureReachabilityReportItem struct {
+ // Provider - The Internet service provider.
+ Provider *string `json:"provider,omitempty"`
+ // AzureLocation - The Azure region.
+ AzureLocation *string `json:"azureLocation,omitempty"`
+ // Latencies - List of latency details for each of the time series.
+ Latencies *[]AzureReachabilityReportLatencyInfo `json:"latencies,omitempty"`
+}
+
+// AzureReachabilityReportLatencyInfo details on latency for a time series.
+type AzureReachabilityReportLatencyInfo struct {
+ // TimeStamp - The time stamp.
+ TimeStamp *date.Time `json:"timeStamp,omitempty"`
+ // Score - The relative latency score between 1 and 100, higher values indicating a faster connection.
+ Score *int32 `json:"score,omitempty"`
+}
+
+// AzureReachabilityReportLocation parameters that define a geographic location.
+type AzureReachabilityReportLocation struct {
+ // Country - The name of the country.
+ Country *string `json:"country,omitempty"`
+ // State - The name of the state.
+ State *string `json:"state,omitempty"`
+ // City - The name of the city or town.
+ City *string `json:"city,omitempty"`
+}
+
+// AzureReachabilityReportParameters geographic and time constraints for Azure reachability report.
+type AzureReachabilityReportParameters struct {
+ ProviderLocation *AzureReachabilityReportLocation `json:"providerLocation,omitempty"`
+ // Providers - List of Internet service providers.
+ Providers *[]string `json:"providers,omitempty"`
+ // AzureLocations - Optional Azure regions to scope the query to.
+ AzureLocations *[]string `json:"azureLocations,omitempty"`
+ // StartTime - The start time for the Azure reachability report.
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // EndTime - The end time for the Azure reachability report.
+ EndTime *date.Time `json:"endTime,omitempty"`
+}
+
+// BackendAddressPool pool of backend IP addresses.
+type BackendAddressPool struct {
+ autorest.Response `json:"-"`
+ // BackendAddressPoolPropertiesFormat - Properties of load balancer backend address pool.
+ *BackendAddressPoolPropertiesFormat `json:"properties,omitempty"`
+ // Name - Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for BackendAddressPool.
+func (bap BackendAddressPool) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if bap.BackendAddressPoolPropertiesFormat != nil {
+ objectMap["properties"] = bap.BackendAddressPoolPropertiesFormat
+ }
+ if bap.Name != nil {
+ objectMap["name"] = bap.Name
+ }
+ if bap.Etag != nil {
+ objectMap["etag"] = bap.Etag
+ }
+ if bap.ID != nil {
+ objectMap["id"] = bap.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for BackendAddressPool struct.
+func (bap *BackendAddressPool) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var backendAddressPoolPropertiesFormat BackendAddressPoolPropertiesFormat
+ err = json.Unmarshal(*v, &backendAddressPoolPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ bap.BackendAddressPoolPropertiesFormat = &backendAddressPoolPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ bap.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ bap.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ bap.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// BackendAddressPoolPropertiesFormat properties of the backend address pool.
+type BackendAddressPoolPropertiesFormat struct {
+ // BackendIPConfigurations - READ-ONLY; Gets collection of references to IP addresses defined in network interfaces.
+ BackendIPConfigurations *[]InterfaceIPConfiguration `json:"backendIPConfigurations,omitempty"`
+ // LoadBalancingRules - READ-ONLY; Gets load balancing rules that use this backend address pool.
+ LoadBalancingRules *[]SubResource `json:"loadBalancingRules,omitempty"`
+ // OutboundNatRule - READ-ONLY; Gets outbound rules that use this backend address pool.
+ OutboundNatRule *SubResource `json:"outboundNatRule,omitempty"`
+ // ProvisioningState - Get provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for BackendAddressPoolPropertiesFormat.
+func (bappf BackendAddressPoolPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if bappf.ProvisioningState != nil {
+ objectMap["provisioningState"] = bappf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// BGPCommunity contains bgp community information offered in Service Community resources.
+type BGPCommunity struct {
+ // ServiceSupportedRegion - The region which the service support. e.g. For O365, region is Global.
+ ServiceSupportedRegion *string `json:"serviceSupportedRegion,omitempty"`
+ // CommunityName - The name of the bgp community. e.g. Skype.
+ CommunityName *string `json:"communityName,omitempty"`
+ // CommunityValue - The value of the bgp community. For more information: https://docs.microsoft.com/en-us/azure/expressroute/expressroute-routing.
+ CommunityValue *string `json:"communityValue,omitempty"`
+ // CommunityPrefixes - The prefixes that the bgp community contains.
+ CommunityPrefixes *[]string `json:"communityPrefixes,omitempty"`
+ // IsAuthorizedToUse - Customer is authorized to use bgp community or not.
+ IsAuthorizedToUse *bool `json:"isAuthorizedToUse,omitempty"`
+ // ServiceGroup - The service group of the bgp community contains.
+ ServiceGroup *string `json:"serviceGroup,omitempty"`
+}
+
+// BgpPeerStatus BGP peer status details
+type BgpPeerStatus struct {
+ // LocalAddress - READ-ONLY; The virtual network gateway's local address
+ LocalAddress *string `json:"localAddress,omitempty"`
+ // Neighbor - READ-ONLY; The remote BGP peer
+ Neighbor *string `json:"neighbor,omitempty"`
+ // Asn - READ-ONLY; The autonomous system number of the remote BGP peer
+ Asn *int32 `json:"asn,omitempty"`
+ // State - READ-ONLY; The BGP peer state. Possible values include: 'BgpPeerStateUnknown', 'BgpPeerStateStopped', 'BgpPeerStateIdle', 'BgpPeerStateConnecting', 'BgpPeerStateConnected'
+ State BgpPeerState `json:"state,omitempty"`
+ // ConnectedDuration - READ-ONLY; For how long the peering has been up
+ ConnectedDuration *string `json:"connectedDuration,omitempty"`
+ // RoutesReceived - READ-ONLY; The number of routes learned from this peer
+ RoutesReceived *int64 `json:"routesReceived,omitempty"`
+ // MessagesSent - READ-ONLY; The number of BGP messages sent
+ MessagesSent *int64 `json:"messagesSent,omitempty"`
+ // MessagesReceived - READ-ONLY; The number of BGP messages received
+ MessagesReceived *int64 `json:"messagesReceived,omitempty"`
+}
+
+// BgpPeerStatusListResult response for list BGP peer status API service call
+type BgpPeerStatusListResult struct {
+ autorest.Response `json:"-"`
+ // Value - List of BGP peers
+ Value *[]BgpPeerStatus `json:"value,omitempty"`
+}
+
+// BgpServiceCommunity service Community Properties.
+type BgpServiceCommunity struct {
+ *BgpServiceCommunityPropertiesFormat `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for BgpServiceCommunity.
+func (bsc BgpServiceCommunity) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if bsc.BgpServiceCommunityPropertiesFormat != nil {
+ objectMap["properties"] = bsc.BgpServiceCommunityPropertiesFormat
+ }
+ if bsc.ID != nil {
+ objectMap["id"] = bsc.ID
+ }
+ if bsc.Location != nil {
+ objectMap["location"] = bsc.Location
+ }
+ if bsc.Tags != nil {
+ objectMap["tags"] = bsc.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for BgpServiceCommunity struct.
+func (bsc *BgpServiceCommunity) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var bgpServiceCommunityPropertiesFormat BgpServiceCommunityPropertiesFormat
+ err = json.Unmarshal(*v, &bgpServiceCommunityPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ bsc.BgpServiceCommunityPropertiesFormat = &bgpServiceCommunityPropertiesFormat
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ bsc.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ bsc.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ bsc.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ bsc.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ bsc.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// BgpServiceCommunityListResult response for the ListServiceCommunity API service call.
+type BgpServiceCommunityListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of service community resources.
+ Value *[]BgpServiceCommunity `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// BgpServiceCommunityListResultIterator provides access to a complete listing of BgpServiceCommunity
+// values.
+type BgpServiceCommunityListResultIterator struct {
+ i int
+ page BgpServiceCommunityListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *BgpServiceCommunityListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/BgpServiceCommunityListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *BgpServiceCommunityListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter BgpServiceCommunityListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter BgpServiceCommunityListResultIterator) Response() BgpServiceCommunityListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter BgpServiceCommunityListResultIterator) Value() BgpServiceCommunity {
+ if !iter.page.NotDone() {
+ return BgpServiceCommunity{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the BgpServiceCommunityListResultIterator type.
+func NewBgpServiceCommunityListResultIterator(page BgpServiceCommunityListResultPage) BgpServiceCommunityListResultIterator {
+ return BgpServiceCommunityListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (bsclr BgpServiceCommunityListResult) IsEmpty() bool {
+ return bsclr.Value == nil || len(*bsclr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (bsclr BgpServiceCommunityListResult) hasNextLink() bool {
+ return bsclr.NextLink != nil && len(*bsclr.NextLink) != 0
+}
+
+// bgpServiceCommunityListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (bsclr BgpServiceCommunityListResult) bgpServiceCommunityListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !bsclr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(bsclr.NextLink)))
+}
+
+// BgpServiceCommunityListResultPage contains a page of BgpServiceCommunity values.
+type BgpServiceCommunityListResultPage struct {
+ fn func(context.Context, BgpServiceCommunityListResult) (BgpServiceCommunityListResult, error)
+ bsclr BgpServiceCommunityListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *BgpServiceCommunityListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/BgpServiceCommunityListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.bsclr)
+ if err != nil {
+ return err
+ }
+ page.bsclr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *BgpServiceCommunityListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page BgpServiceCommunityListResultPage) NotDone() bool {
+ return !page.bsclr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page BgpServiceCommunityListResultPage) Response() BgpServiceCommunityListResult {
+ return page.bsclr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page BgpServiceCommunityListResultPage) Values() []BgpServiceCommunity {
+ if page.bsclr.IsEmpty() {
+ return nil
+ }
+ return *page.bsclr.Value
+}
+
+// Creates a new instance of the BgpServiceCommunityListResultPage type.
+func NewBgpServiceCommunityListResultPage(cur BgpServiceCommunityListResult, getNextPage func(context.Context, BgpServiceCommunityListResult) (BgpServiceCommunityListResult, error)) BgpServiceCommunityListResultPage {
+ return BgpServiceCommunityListResultPage{
+ fn: getNextPage,
+ bsclr: cur,
+ }
+}
+
+// BgpServiceCommunityPropertiesFormat properties of Service Community.
+type BgpServiceCommunityPropertiesFormat struct {
+ // ServiceName - The name of the bgp community. e.g. Skype.
+ ServiceName *string `json:"serviceName,omitempty"`
+ // BgpCommunities - Get a list of bgp communities.
+ BgpCommunities *[]BGPCommunity `json:"bgpCommunities,omitempty"`
+}
+
+// BgpSettings BGP settings details
+type BgpSettings struct {
+ // Asn - The BGP speaker's ASN.
+ Asn *int64 `json:"asn,omitempty"`
+ // BgpPeeringAddress - The BGP peering address and BGP identifier of this BGP speaker.
+ BgpPeeringAddress *string `json:"bgpPeeringAddress,omitempty"`
+ // PeerWeight - The weight added to routes learned from this BGP speaker.
+ PeerWeight *int32 `json:"peerWeight,omitempty"`
+}
+
+// ConnectionMonitor parameters that define the operation to create a connection monitor.
+type ConnectionMonitor struct {
+ // Location - Connection monitor location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Connection monitor tags.
+ Tags map[string]*string `json:"tags"`
+ *ConnectionMonitorParameters `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ConnectionMonitor.
+func (cm ConnectionMonitor) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if cm.Location != nil {
+ objectMap["location"] = cm.Location
+ }
+ if cm.Tags != nil {
+ objectMap["tags"] = cm.Tags
+ }
+ if cm.ConnectionMonitorParameters != nil {
+ objectMap["properties"] = cm.ConnectionMonitorParameters
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ConnectionMonitor struct.
+func (cm *ConnectionMonitor) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ cm.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ cm.Tags = tags
+ }
+ case "properties":
+ if v != nil {
+ var connectionMonitorParameters ConnectionMonitorParameters
+ err = json.Unmarshal(*v, &connectionMonitorParameters)
+ if err != nil {
+ return err
+ }
+ cm.ConnectionMonitorParameters = &connectionMonitorParameters
+ }
+ }
+ }
+
+ return nil
+}
+
+// ConnectionMonitorDestination describes the destination of connection monitor.
+type ConnectionMonitorDestination struct {
+ // ResourceID - The ID of the resource used as the destination by connection monitor.
+ ResourceID *string `json:"resourceId,omitempty"`
+ // Address - Address of the connection monitor destination (IP or domain name).
+ Address *string `json:"address,omitempty"`
+ // Port - The destination port used by connection monitor.
+ Port *int32 `json:"port,omitempty"`
+}
+
+// ConnectionMonitorListResult list of connection monitors.
+type ConnectionMonitorListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Information about connection monitors.
+ Value *[]ConnectionMonitorResult `json:"value,omitempty"`
+}
+
+// ConnectionMonitorParameters parameters that define the operation to create a connection monitor.
+type ConnectionMonitorParameters struct {
+ Source *ConnectionMonitorSource `json:"source,omitempty"`
+ Destination *ConnectionMonitorDestination `json:"destination,omitempty"`
+ // AutoStart - Determines if the connection monitor will start automatically once created.
+ AutoStart *bool `json:"autoStart,omitempty"`
+ // MonitoringIntervalInSeconds - Monitoring interval in seconds.
+ MonitoringIntervalInSeconds *int32 `json:"monitoringIntervalInSeconds,omitempty"`
+}
+
+// ConnectionMonitorQueryResult list of connection states snapshots.
+type ConnectionMonitorQueryResult struct {
+ autorest.Response `json:"-"`
+ // States - Information about connection states.
+ States *[]ConnectionStateSnapshot `json:"states,omitempty"`
+}
+
+// ConnectionMonitorResult information about the connection monitor.
+type ConnectionMonitorResult struct {
+ autorest.Response `json:"-"`
+ // Name - READ-ONLY; Name of the connection monitor.
+ Name *string `json:"name,omitempty"`
+ // ID - READ-ONLY; ID of the connection monitor.
+ ID *string `json:"id,omitempty"`
+ Etag *string `json:"etag,omitempty"`
+ // Type - READ-ONLY; Connection monitor type.
+ Type *string `json:"type,omitempty"`
+ // Location - Connection monitor location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Connection monitor tags.
+ Tags map[string]*string `json:"tags"`
+ *ConnectionMonitorResultProperties `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ConnectionMonitorResult.
+func (cmr ConnectionMonitorResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if cmr.Etag != nil {
+ objectMap["etag"] = cmr.Etag
+ }
+ if cmr.Location != nil {
+ objectMap["location"] = cmr.Location
+ }
+ if cmr.Tags != nil {
+ objectMap["tags"] = cmr.Tags
+ }
+ if cmr.ConnectionMonitorResultProperties != nil {
+ objectMap["properties"] = cmr.ConnectionMonitorResultProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ConnectionMonitorResult struct.
+func (cmr *ConnectionMonitorResult) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ cmr.Name = &name
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ cmr.ID = &ID
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ cmr.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ cmr.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ cmr.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ cmr.Tags = tags
+ }
+ case "properties":
+ if v != nil {
+ var connectionMonitorResultProperties ConnectionMonitorResultProperties
+ err = json.Unmarshal(*v, &connectionMonitorResultProperties)
+ if err != nil {
+ return err
+ }
+ cmr.ConnectionMonitorResultProperties = &connectionMonitorResultProperties
+ }
+ }
+ }
+
+ return nil
+}
+
+// ConnectionMonitorResultProperties describes the properties of a connection monitor.
+type ConnectionMonitorResultProperties struct {
+ // ProvisioningState - The provisioning state of the connection monitor. Possible values include: 'Succeeded', 'Updating', 'Deleting', 'Failed'
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+ // StartTime - The date and time when the connection monitor was started.
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // MonitoringStatus - The monitoring status of the connection monitor.
+ MonitoringStatus *string `json:"monitoringStatus,omitempty"`
+ Source *ConnectionMonitorSource `json:"source,omitempty"`
+ Destination *ConnectionMonitorDestination `json:"destination,omitempty"`
+ // AutoStart - Determines if the connection monitor will start automatically once created.
+ AutoStart *bool `json:"autoStart,omitempty"`
+ // MonitoringIntervalInSeconds - Monitoring interval in seconds.
+ MonitoringIntervalInSeconds *int32 `json:"monitoringIntervalInSeconds,omitempty"`
+}
+
+// ConnectionMonitorsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ConnectionMonitorsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ConnectionMonitorsClient) (ConnectionMonitorResult, error)
+}
+
+// ConnectionMonitorsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ConnectionMonitorsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ConnectionMonitorsClient) (autorest.Response, error)
+}
+
+// ConnectionMonitorSource describes the source of connection monitor.
+type ConnectionMonitorSource struct {
+ // ResourceID - The ID of the resource used as the source by connection monitor.
+ ResourceID *string `json:"resourceId,omitempty"`
+ // Port - The source port used by connection monitor.
+ Port *int32 `json:"port,omitempty"`
+}
+
+// ConnectionMonitorsQueryFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type ConnectionMonitorsQueryFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ConnectionMonitorsClient) (ConnectionMonitorQueryResult, error)
+}
+
+// ConnectionMonitorsStartFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type ConnectionMonitorsStartFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ConnectionMonitorsClient) (autorest.Response, error)
+}
+
+// ConnectionMonitorsStopFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type ConnectionMonitorsStopFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ConnectionMonitorsClient) (autorest.Response, error)
+}
+
+// ConnectionResetSharedKey the virtual network connection reset shared key
+type ConnectionResetSharedKey struct {
+ autorest.Response `json:"-"`
+ // KeyLength - The virtual network connection reset shared key length, should between 1 and 128.
+ KeyLength *int32 `json:"keyLength,omitempty"`
+}
+
+// ConnectionSharedKey response for GetConnectionSharedKey API service call
+type ConnectionSharedKey struct {
+ autorest.Response `json:"-"`
+ // Value - The virtual network connection shared key value.
+ Value *string `json:"value,omitempty"`
+}
+
+// ConnectionStateSnapshot connection state snapshot.
+type ConnectionStateSnapshot struct {
+ // ConnectionState - The connection state. Possible values include: 'ConnectionStateReachable', 'ConnectionStateUnreachable', 'ConnectionStateUnknown'
+ ConnectionState ConnectionState `json:"connectionState,omitempty"`
+ // StartTime - The start time of the connection snapshot.
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // EndTime - The end time of the connection snapshot.
+ EndTime *date.Time `json:"endTime,omitempty"`
+ // EvaluationState - Connectivity analysis evaluation state. Possible values include: 'NotStarted', 'InProgress', 'Completed'
+ EvaluationState EvaluationState `json:"evaluationState,omitempty"`
+ // Hops - READ-ONLY; List of hops between the source and the destination.
+ Hops *[]ConnectivityHop `json:"hops,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ConnectionStateSnapshot.
+func (CSS ConnectionStateSnapshot) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if CSS.ConnectionState != "" {
+ objectMap["connectionState"] = CSS.ConnectionState
+ }
+ if CSS.StartTime != nil {
+ objectMap["startTime"] = CSS.StartTime
+ }
+ if CSS.EndTime != nil {
+ objectMap["endTime"] = CSS.EndTime
+ }
+ if CSS.EvaluationState != "" {
+ objectMap["evaluationState"] = CSS.EvaluationState
+ }
+ return json.Marshal(objectMap)
+}
+
+// ConnectivityDestination parameters that define destination of connection.
+type ConnectivityDestination struct {
+ // ResourceID - The ID of the resource to which a connection attempt will be made.
+ ResourceID *string `json:"resourceId,omitempty"`
+ // Address - The IP address or URI the resource to which a connection attempt will be made.
+ Address *string `json:"address,omitempty"`
+ // Port - Port on which check connectivity will be performed.
+ Port *int32 `json:"port,omitempty"`
+}
+
+// ConnectivityHop information about a hop between the source and the destination.
+type ConnectivityHop struct {
+ // Type - READ-ONLY; The type of the hop.
+ Type *string `json:"type,omitempty"`
+ // ID - READ-ONLY; The ID of the hop.
+ ID *string `json:"id,omitempty"`
+ // Address - READ-ONLY; The IP address of the hop.
+ Address *string `json:"address,omitempty"`
+ // ResourceID - READ-ONLY; The ID of the resource corresponding to this hop.
+ ResourceID *string `json:"resourceId,omitempty"`
+ // NextHopIds - READ-ONLY; List of next hop identifiers.
+ NextHopIds *[]string `json:"nextHopIds,omitempty"`
+ // Issues - READ-ONLY; List of issues.
+ Issues *[]ConnectivityIssue `json:"issues,omitempty"`
+}
+
+// ConnectivityInformation information on the connectivity status.
+type ConnectivityInformation struct {
+ autorest.Response `json:"-"`
+ // Hops - READ-ONLY; List of hops between the source and the destination.
+ Hops *[]ConnectivityHop `json:"hops,omitempty"`
+ // ConnectionStatus - READ-ONLY; The connection status. Possible values include: 'ConnectionStatusUnknown', 'ConnectionStatusConnected', 'ConnectionStatusDisconnected', 'ConnectionStatusDegraded'
+ ConnectionStatus ConnectionStatus `json:"connectionStatus,omitempty"`
+ // AvgLatencyInMs - READ-ONLY; Average latency in milliseconds.
+ AvgLatencyInMs *int32 `json:"avgLatencyInMs,omitempty"`
+ // MinLatencyInMs - READ-ONLY; Minimum latency in milliseconds.
+ MinLatencyInMs *int32 `json:"minLatencyInMs,omitempty"`
+ // MaxLatencyInMs - READ-ONLY; Maximum latency in milliseconds.
+ MaxLatencyInMs *int32 `json:"maxLatencyInMs,omitempty"`
+ // ProbesSent - READ-ONLY; Total number of probes sent.
+ ProbesSent *int32 `json:"probesSent,omitempty"`
+ // ProbesFailed - READ-ONLY; Number of failed probes.
+ ProbesFailed *int32 `json:"probesFailed,omitempty"`
+}
+
+// ConnectivityIssue information about an issue encountered in the process of checking for connectivity.
+type ConnectivityIssue struct {
+ // Origin - READ-ONLY; The origin of the issue. Possible values include: 'OriginLocal', 'OriginInbound', 'OriginOutbound'
+ Origin Origin `json:"origin,omitempty"`
+ // Severity - READ-ONLY; The severity of the issue. Possible values include: 'SeverityError', 'SeverityWarning'
+ Severity Severity `json:"severity,omitempty"`
+ // Type - READ-ONLY; The type of issue. Possible values include: 'IssueTypeUnknown', 'IssueTypeAgentStopped', 'IssueTypeGuestFirewall', 'IssueTypeDNSResolution', 'IssueTypeSocketBind', 'IssueTypeNetworkSecurityRule', 'IssueTypeUserDefinedRoute', 'IssueTypePortThrottled', 'IssueTypePlatform'
+ Type IssueType `json:"type,omitempty"`
+ // Context - READ-ONLY; Provides additional context on the issue.
+ Context *[]map[string]*string `json:"context,omitempty"`
+}
+
+// ConnectivityParameters parameters that determine how the connectivity check will be performed.
+type ConnectivityParameters struct {
+ Source *ConnectivitySource `json:"source,omitempty"`
+ Destination *ConnectivityDestination `json:"destination,omitempty"`
+}
+
+// ConnectivitySource parameters that define the source of the connection.
+type ConnectivitySource struct {
+ // ResourceID - The ID of the resource from which a connectivity check will be initiated.
+ ResourceID *string `json:"resourceId,omitempty"`
+ // Port - The source port from which a connectivity check will be performed.
+ Port *int32 `json:"port,omitempty"`
+}
+
+// DhcpOptions dhcpOptions contains an array of DNS servers available to VMs deployed in the virtual
+// network. Standard DHCP option for a subnet overrides VNET DHCP options.
+type DhcpOptions struct {
+ // DNSServers - The list of DNS servers IP addresses.
+ DNSServers *[]string `json:"dnsServers,omitempty"`
+}
+
+// Dimension dimension of the metric.
+type Dimension struct {
+ // Name - The name of the dimension.
+ Name *string `json:"name,omitempty"`
+ // DisplayName - The display name of the dimension.
+ DisplayName *string `json:"displayName,omitempty"`
+ // InternalName - The internal name of the dimension.
+ InternalName *string `json:"internalName,omitempty"`
+}
+
+// DNSNameAvailabilityResult response for the CheckDnsNameAvailability API service call.
+type DNSNameAvailabilityResult struct {
+ autorest.Response `json:"-"`
+ // Available - Domain availability (True/False).
+ Available *bool `json:"available,omitempty"`
+}
+
+// EffectiveNetworkSecurityGroup effective network security group.
+type EffectiveNetworkSecurityGroup struct {
+ // NetworkSecurityGroup - The ID of network security group that is applied.
+ NetworkSecurityGroup *SubResource `json:"networkSecurityGroup,omitempty"`
+ // Association - Associated resources.
+ Association *EffectiveNetworkSecurityGroupAssociation `json:"association,omitempty"`
+ // EffectiveSecurityRules - A collection of effective security rules.
+ EffectiveSecurityRules *[]EffectiveNetworkSecurityRule `json:"effectiveSecurityRules,omitempty"`
+ // TagMap - Mapping of tags to list of IP Addresses included within the tag.
+ TagMap map[string][]string `json:"tagMap"`
+}
+
+// MarshalJSON is the custom marshaler for EffectiveNetworkSecurityGroup.
+func (ensg EffectiveNetworkSecurityGroup) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ensg.NetworkSecurityGroup != nil {
+ objectMap["networkSecurityGroup"] = ensg.NetworkSecurityGroup
+ }
+ if ensg.Association != nil {
+ objectMap["association"] = ensg.Association
+ }
+ if ensg.EffectiveSecurityRules != nil {
+ objectMap["effectiveSecurityRules"] = ensg.EffectiveSecurityRules
+ }
+ if ensg.TagMap != nil {
+ objectMap["tagMap"] = ensg.TagMap
+ }
+ return json.Marshal(objectMap)
+}
+
+// EffectiveNetworkSecurityGroupAssociation the effective network security group association.
+type EffectiveNetworkSecurityGroupAssociation struct {
+ // Subnet - The ID of the subnet if assigned.
+ Subnet *SubResource `json:"subnet,omitempty"`
+ // NetworkInterface - The ID of the network interface if assigned.
+ NetworkInterface *SubResource `json:"networkInterface,omitempty"`
+}
+
+// EffectiveNetworkSecurityGroupListResult response for list effective network security groups API service
+// call.
+type EffectiveNetworkSecurityGroupListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of effective network security groups.
+ Value *[]EffectiveNetworkSecurityGroup `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for EffectiveNetworkSecurityGroupListResult.
+func (ensglr EffectiveNetworkSecurityGroupListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ensglr.Value != nil {
+ objectMap["value"] = ensglr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// EffectiveNetworkSecurityRule effective network security rules.
+type EffectiveNetworkSecurityRule struct {
+ // Name - The name of the security rule specified by the user (if created by the user).
+ Name *string `json:"name,omitempty"`
+ // Protocol - The network protocol this rule applies to. Possible values are: 'Tcp', 'Udp', and 'All'. Possible values include: 'TCP', 'UDP', 'All'
+ Protocol EffectiveSecurityRuleProtocol `json:"protocol,omitempty"`
+ // SourcePortRange - The source port or range.
+ SourcePortRange *string `json:"sourcePortRange,omitempty"`
+ // DestinationPortRange - The destination port or range.
+ DestinationPortRange *string `json:"destinationPortRange,omitempty"`
+ // SourcePortRanges - The source port ranges. Expected values include a single integer between 0 and 65535, a range using '-' as separator (e.g. 100-400), or an asterisk (*)
+ SourcePortRanges *[]string `json:"sourcePortRanges,omitempty"`
+ // DestinationPortRanges - The destination port ranges. Expected values include a single integer between 0 and 65535, a range using '-' as separator (e.g. 100-400), or an asterisk (*)
+ DestinationPortRanges *[]string `json:"destinationPortRanges,omitempty"`
+ // SourceAddressPrefix - The source address prefix.
+ SourceAddressPrefix *string `json:"sourceAddressPrefix,omitempty"`
+ // DestinationAddressPrefix - The destination address prefix.
+ DestinationAddressPrefix *string `json:"destinationAddressPrefix,omitempty"`
+ // SourceAddressPrefixes - The source address prefixes. Expected values include CIDR IP ranges, Default Tags (VirtualNetwork, AzureLoadBalancer, Internet), System Tags, and the asterisk (*).
+ SourceAddressPrefixes *[]string `json:"sourceAddressPrefixes,omitempty"`
+ // DestinationAddressPrefixes - The destination address prefixes. Expected values include CIDR IP ranges, Default Tags (VirtualNetwork, AzureLoadBalancer, Internet), System Tags, and the asterisk (*).
+ DestinationAddressPrefixes *[]string `json:"destinationAddressPrefixes,omitempty"`
+ // ExpandedSourceAddressPrefix - The expanded source address prefix.
+ ExpandedSourceAddressPrefix *[]string `json:"expandedSourceAddressPrefix,omitempty"`
+ // ExpandedDestinationAddressPrefix - Expanded destination address prefix.
+ ExpandedDestinationAddressPrefix *[]string `json:"expandedDestinationAddressPrefix,omitempty"`
+ // Access - Whether network traffic is allowed or denied. Possible values are: 'Allow' and 'Deny'. Possible values include: 'SecurityRuleAccessAllow', 'SecurityRuleAccessDeny'
+ Access SecurityRuleAccess `json:"access,omitempty"`
+ // Priority - The priority of the rule.
+ Priority *int32 `json:"priority,omitempty"`
+ // Direction - The direction of the rule. Possible values are: 'Inbound and Outbound'. Possible values include: 'SecurityRuleDirectionInbound', 'SecurityRuleDirectionOutbound'
+ Direction SecurityRuleDirection `json:"direction,omitempty"`
+}
+
+// EffectiveRoute effective Route
+type EffectiveRoute struct {
+ // Name - The name of the user defined route. This is optional.
+ Name *string `json:"name,omitempty"`
+ // Source - Who created the route. Possible values are: 'Unknown', 'User', 'VirtualNetworkGateway', and 'Default'. Possible values include: 'EffectiveRouteSourceUnknown', 'EffectiveRouteSourceUser', 'EffectiveRouteSourceVirtualNetworkGateway', 'EffectiveRouteSourceDefault'
+ Source EffectiveRouteSource `json:"source,omitempty"`
+ // State - The value of effective route. Possible values are: 'Active' and 'Invalid'. Possible values include: 'Active', 'Invalid'
+ State EffectiveRouteState `json:"state,omitempty"`
+ // AddressPrefix - The address prefixes of the effective routes in CIDR notation.
+ AddressPrefix *[]string `json:"addressPrefix,omitempty"`
+ // NextHopIPAddress - The IP address of the next hop of the effective route.
+ NextHopIPAddress *[]string `json:"nextHopIpAddress,omitempty"`
+ // NextHopType - The type of Azure hop the packet should be sent to. Possible values are: 'VirtualNetworkGateway', 'VnetLocal', 'Internet', 'VirtualAppliance', and 'None'. Possible values include: 'RouteNextHopTypeVirtualNetworkGateway', 'RouteNextHopTypeVnetLocal', 'RouteNextHopTypeInternet', 'RouteNextHopTypeVirtualAppliance', 'RouteNextHopTypeNone'
+ NextHopType RouteNextHopType `json:"nextHopType,omitempty"`
+}
+
+// EffectiveRouteListResult response for list effective route API service call.
+type EffectiveRouteListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of effective routes.
+ Value *[]EffectiveRoute `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for EffectiveRouteListResult.
+func (erlr EffectiveRouteListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if erlr.Value != nil {
+ objectMap["value"] = erlr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// EndpointServiceResult endpoint service.
+type EndpointServiceResult struct {
+ // Name - READ-ONLY; Name of the endpoint service.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Type of the endpoint service.
+ Type *string `json:"type,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for EndpointServiceResult.
+func (esr EndpointServiceResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if esr.ID != nil {
+ objectMap["id"] = esr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// EndpointServicesListResult response for the ListAvailableEndpointServices API service call.
+type EndpointServicesListResult struct {
+ autorest.Response `json:"-"`
+ // Value - List of available endpoint services in a region.
+ Value *[]EndpointServiceResult `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// EndpointServicesListResultIterator provides access to a complete listing of EndpointServiceResult
+// values.
+type EndpointServicesListResultIterator struct {
+ i int
+ page EndpointServicesListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *EndpointServicesListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/EndpointServicesListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *EndpointServicesListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter EndpointServicesListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter EndpointServicesListResultIterator) Response() EndpointServicesListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter EndpointServicesListResultIterator) Value() EndpointServiceResult {
+ if !iter.page.NotDone() {
+ return EndpointServiceResult{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the EndpointServicesListResultIterator type.
+func NewEndpointServicesListResultIterator(page EndpointServicesListResultPage) EndpointServicesListResultIterator {
+ return EndpointServicesListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (eslr EndpointServicesListResult) IsEmpty() bool {
+ return eslr.Value == nil || len(*eslr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (eslr EndpointServicesListResult) hasNextLink() bool {
+ return eslr.NextLink != nil && len(*eslr.NextLink) != 0
+}
+
+// endpointServicesListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (eslr EndpointServicesListResult) endpointServicesListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !eslr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(eslr.NextLink)))
+}
+
+// EndpointServicesListResultPage contains a page of EndpointServiceResult values.
+type EndpointServicesListResultPage struct {
+ fn func(context.Context, EndpointServicesListResult) (EndpointServicesListResult, error)
+ eslr EndpointServicesListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *EndpointServicesListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/EndpointServicesListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.eslr)
+ if err != nil {
+ return err
+ }
+ page.eslr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *EndpointServicesListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page EndpointServicesListResultPage) NotDone() bool {
+ return !page.eslr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page EndpointServicesListResultPage) Response() EndpointServicesListResult {
+ return page.eslr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page EndpointServicesListResultPage) Values() []EndpointServiceResult {
+ if page.eslr.IsEmpty() {
+ return nil
+ }
+ return *page.eslr.Value
+}
+
+// Creates a new instance of the EndpointServicesListResultPage type.
+func NewEndpointServicesListResultPage(cur EndpointServicesListResult, getNextPage func(context.Context, EndpointServicesListResult) (EndpointServicesListResult, error)) EndpointServicesListResultPage {
+ return EndpointServicesListResultPage{
+ fn: getNextPage,
+ eslr: cur,
+ }
+}
+
+// Error ...
+type Error struct {
+ Code *string `json:"code,omitempty"`
+ Message *string `json:"message,omitempty"`
+ Target *string `json:"target,omitempty"`
+ Details *[]ErrorDetails `json:"details,omitempty"`
+ InnerError *string `json:"innerError,omitempty"`
+}
+
+// ErrorDetails ...
+type ErrorDetails struct {
+ Code *string `json:"code,omitempty"`
+ Target *string `json:"target,omitempty"`
+ Message *string `json:"message,omitempty"`
+}
+
+// ExpressRouteCircuit expressRouteCircuit resource
+type ExpressRouteCircuit struct {
+ autorest.Response `json:"-"`
+ // Sku - The SKU.
+ Sku *ExpressRouteCircuitSku `json:"sku,omitempty"`
+ *ExpressRouteCircuitPropertiesFormat `json:"properties,omitempty"`
+ // Etag - READ-ONLY; Gets a unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for ExpressRouteCircuit.
+func (erc ExpressRouteCircuit) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if erc.Sku != nil {
+ objectMap["sku"] = erc.Sku
+ }
+ if erc.ExpressRouteCircuitPropertiesFormat != nil {
+ objectMap["properties"] = erc.ExpressRouteCircuitPropertiesFormat
+ }
+ if erc.ID != nil {
+ objectMap["id"] = erc.ID
+ }
+ if erc.Location != nil {
+ objectMap["location"] = erc.Location
+ }
+ if erc.Tags != nil {
+ objectMap["tags"] = erc.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ExpressRouteCircuit struct.
+func (erc *ExpressRouteCircuit) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku ExpressRouteCircuitSku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ erc.Sku = &sku
+ }
+ case "properties":
+ if v != nil {
+ var expressRouteCircuitPropertiesFormat ExpressRouteCircuitPropertiesFormat
+ err = json.Unmarshal(*v, &expressRouteCircuitPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ erc.ExpressRouteCircuitPropertiesFormat = &expressRouteCircuitPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ erc.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ erc.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ erc.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ erc.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ erc.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ erc.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// ExpressRouteCircuitArpTable the ARP table associated with the ExpressRouteCircuit.
+type ExpressRouteCircuitArpTable struct {
+ // Age - Age
+ Age *int32 `json:"age,omitempty"`
+ // Interface - Interface
+ Interface *string `json:"interface,omitempty"`
+ // IPAddress - The IP address.
+ IPAddress *string `json:"ipAddress,omitempty"`
+ // MacAddress - The MAC address.
+ MacAddress *string `json:"macAddress,omitempty"`
+}
+
+// ExpressRouteCircuitAuthorization authorization in an ExpressRouteCircuit resource.
+type ExpressRouteCircuitAuthorization struct {
+ autorest.Response `json:"-"`
+ *AuthorizationPropertiesFormat `json:"properties,omitempty"`
+ // Name - Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - READ-ONLY; A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ExpressRouteCircuitAuthorization.
+func (erca ExpressRouteCircuitAuthorization) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if erca.AuthorizationPropertiesFormat != nil {
+ objectMap["properties"] = erca.AuthorizationPropertiesFormat
+ }
+ if erca.Name != nil {
+ objectMap["name"] = erca.Name
+ }
+ if erca.ID != nil {
+ objectMap["id"] = erca.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ExpressRouteCircuitAuthorization struct.
+func (erca *ExpressRouteCircuitAuthorization) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var authorizationPropertiesFormat AuthorizationPropertiesFormat
+ err = json.Unmarshal(*v, &authorizationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ erca.AuthorizationPropertiesFormat = &authorizationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ erca.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ erca.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ erca.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type ExpressRouteCircuitAuthorizationsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitAuthorizationsClient) (ExpressRouteCircuitAuthorization, error)
+}
+
+// ExpressRouteCircuitAuthorizationsDeleteFuture an abstraction for monitoring and retrieving the results
+// of a long-running operation.
+type ExpressRouteCircuitAuthorizationsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitAuthorizationsClient) (autorest.Response, error)
+}
+
+// ExpressRouteCircuitListResult response for ListExpressRouteCircuit API service call.
+type ExpressRouteCircuitListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of ExpressRouteCircuits in a resource group.
+ Value *[]ExpressRouteCircuit `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ExpressRouteCircuitListResultIterator provides access to a complete listing of ExpressRouteCircuit
+// values.
+type ExpressRouteCircuitListResultIterator struct {
+ i int
+ page ExpressRouteCircuitListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ExpressRouteCircuitListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ExpressRouteCircuitListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ExpressRouteCircuitListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ExpressRouteCircuitListResultIterator) Response() ExpressRouteCircuitListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ExpressRouteCircuitListResultIterator) Value() ExpressRouteCircuit {
+ if !iter.page.NotDone() {
+ return ExpressRouteCircuit{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ExpressRouteCircuitListResultIterator type.
+func NewExpressRouteCircuitListResultIterator(page ExpressRouteCircuitListResultPage) ExpressRouteCircuitListResultIterator {
+ return ExpressRouteCircuitListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (erclr ExpressRouteCircuitListResult) IsEmpty() bool {
+ return erclr.Value == nil || len(*erclr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (erclr ExpressRouteCircuitListResult) hasNextLink() bool {
+ return erclr.NextLink != nil && len(*erclr.NextLink) != 0
+}
+
+// expressRouteCircuitListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (erclr ExpressRouteCircuitListResult) expressRouteCircuitListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !erclr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(erclr.NextLink)))
+}
+
+// ExpressRouteCircuitListResultPage contains a page of ExpressRouteCircuit values.
+type ExpressRouteCircuitListResultPage struct {
+ fn func(context.Context, ExpressRouteCircuitListResult) (ExpressRouteCircuitListResult, error)
+ erclr ExpressRouteCircuitListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ExpressRouteCircuitListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.erclr)
+ if err != nil {
+ return err
+ }
+ page.erclr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ExpressRouteCircuitListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ExpressRouteCircuitListResultPage) NotDone() bool {
+ return !page.erclr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ExpressRouteCircuitListResultPage) Response() ExpressRouteCircuitListResult {
+ return page.erclr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ExpressRouteCircuitListResultPage) Values() []ExpressRouteCircuit {
+ if page.erclr.IsEmpty() {
+ return nil
+ }
+ return *page.erclr.Value
+}
+
+// Creates a new instance of the ExpressRouteCircuitListResultPage type.
+func NewExpressRouteCircuitListResultPage(cur ExpressRouteCircuitListResult, getNextPage func(context.Context, ExpressRouteCircuitListResult) (ExpressRouteCircuitListResult, error)) ExpressRouteCircuitListResultPage {
+ return ExpressRouteCircuitListResultPage{
+ fn: getNextPage,
+ erclr: cur,
+ }
+}
+
+// ExpressRouteCircuitPeering peering in an ExpressRouteCircuit resource.
+type ExpressRouteCircuitPeering struct {
+ autorest.Response `json:"-"`
+ *ExpressRouteCircuitPeeringPropertiesFormat `json:"properties,omitempty"`
+ // Name - Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - READ-ONLY; A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ExpressRouteCircuitPeering.
+func (ercp ExpressRouteCircuitPeering) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ercp.ExpressRouteCircuitPeeringPropertiesFormat != nil {
+ objectMap["properties"] = ercp.ExpressRouteCircuitPeeringPropertiesFormat
+ }
+ if ercp.Name != nil {
+ objectMap["name"] = ercp.Name
+ }
+ if ercp.ID != nil {
+ objectMap["id"] = ercp.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ExpressRouteCircuitPeering struct.
+func (ercp *ExpressRouteCircuitPeering) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var expressRouteCircuitPeeringPropertiesFormat ExpressRouteCircuitPeeringPropertiesFormat
+ err = json.Unmarshal(*v, &expressRouteCircuitPeeringPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ ercp.ExpressRouteCircuitPeeringPropertiesFormat = &expressRouteCircuitPeeringPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ ercp.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ ercp.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ ercp.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ExpressRouteCircuitPeeringConfig specifies the peering configuration.
+type ExpressRouteCircuitPeeringConfig struct {
+ // AdvertisedPublicPrefixes - The reference of AdvertisedPublicPrefixes.
+ AdvertisedPublicPrefixes *[]string `json:"advertisedPublicPrefixes,omitempty"`
+ // AdvertisedCommunities - The communities of bgp peering. Specified for microsoft peering
+ AdvertisedCommunities *[]string `json:"advertisedCommunities,omitempty"`
+ // AdvertisedPublicPrefixesState - AdvertisedPublicPrefixState of the Peering resource. Possible values are 'NotConfigured', 'Configuring', 'Configured', and 'ValidationNeeded'. Possible values include: 'NotConfigured', 'Configuring', 'Configured', 'ValidationNeeded'
+ AdvertisedPublicPrefixesState ExpressRouteCircuitPeeringAdvertisedPublicPrefixState `json:"advertisedPublicPrefixesState,omitempty"`
+ // LegacyMode - The legacy mode of the peering.
+ LegacyMode *int32 `json:"legacyMode,omitempty"`
+ // CustomerASN - The CustomerASN of the peering.
+ CustomerASN *int32 `json:"customerASN,omitempty"`
+ // RoutingRegistryName - The RoutingRegistryName of the configuration.
+ RoutingRegistryName *string `json:"routingRegistryName,omitempty"`
+}
+
+// ExpressRouteCircuitPeeringListResult response for ListPeering API service call retrieves all peerings
+// that belong to an ExpressRouteCircuit.
+type ExpressRouteCircuitPeeringListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The peerings in an express route circuit.
+ Value *[]ExpressRouteCircuitPeering `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ExpressRouteCircuitPeeringListResultIterator provides access to a complete listing of
+// ExpressRouteCircuitPeering values.
+type ExpressRouteCircuitPeeringListResultIterator struct {
+ i int
+ page ExpressRouteCircuitPeeringListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ExpressRouteCircuitPeeringListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitPeeringListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ExpressRouteCircuitPeeringListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ExpressRouteCircuitPeeringListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ExpressRouteCircuitPeeringListResultIterator) Response() ExpressRouteCircuitPeeringListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ExpressRouteCircuitPeeringListResultIterator) Value() ExpressRouteCircuitPeering {
+ if !iter.page.NotDone() {
+ return ExpressRouteCircuitPeering{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ExpressRouteCircuitPeeringListResultIterator type.
+func NewExpressRouteCircuitPeeringListResultIterator(page ExpressRouteCircuitPeeringListResultPage) ExpressRouteCircuitPeeringListResultIterator {
+ return ExpressRouteCircuitPeeringListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (ercplr ExpressRouteCircuitPeeringListResult) IsEmpty() bool {
+ return ercplr.Value == nil || len(*ercplr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (ercplr ExpressRouteCircuitPeeringListResult) hasNextLink() bool {
+ return ercplr.NextLink != nil && len(*ercplr.NextLink) != 0
+}
+
+// expressRouteCircuitPeeringListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (ercplr ExpressRouteCircuitPeeringListResult) expressRouteCircuitPeeringListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !ercplr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(ercplr.NextLink)))
+}
+
+// ExpressRouteCircuitPeeringListResultPage contains a page of ExpressRouteCircuitPeering values.
+type ExpressRouteCircuitPeeringListResultPage struct {
+ fn func(context.Context, ExpressRouteCircuitPeeringListResult) (ExpressRouteCircuitPeeringListResult, error)
+ ercplr ExpressRouteCircuitPeeringListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ExpressRouteCircuitPeeringListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitPeeringListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.ercplr)
+ if err != nil {
+ return err
+ }
+ page.ercplr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ExpressRouteCircuitPeeringListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ExpressRouteCircuitPeeringListResultPage) NotDone() bool {
+ return !page.ercplr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ExpressRouteCircuitPeeringListResultPage) Response() ExpressRouteCircuitPeeringListResult {
+ return page.ercplr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ExpressRouteCircuitPeeringListResultPage) Values() []ExpressRouteCircuitPeering {
+ if page.ercplr.IsEmpty() {
+ return nil
+ }
+ return *page.ercplr.Value
+}
+
+// Creates a new instance of the ExpressRouteCircuitPeeringListResultPage type.
+func NewExpressRouteCircuitPeeringListResultPage(cur ExpressRouteCircuitPeeringListResult, getNextPage func(context.Context, ExpressRouteCircuitPeeringListResult) (ExpressRouteCircuitPeeringListResult, error)) ExpressRouteCircuitPeeringListResultPage {
+ return ExpressRouteCircuitPeeringListResultPage{
+ fn: getNextPage,
+ ercplr: cur,
+ }
+}
+
+// ExpressRouteCircuitPeeringPropertiesFormat ...
+type ExpressRouteCircuitPeeringPropertiesFormat struct {
+ // PeeringType - The PeeringType. Possible values are: 'AzurePublicPeering', 'AzurePrivatePeering', and 'MicrosoftPeering'. Possible values include: 'AzurePublicPeering', 'AzurePrivatePeering', 'MicrosoftPeering'
+ PeeringType ExpressRouteCircuitPeeringType `json:"peeringType,omitempty"`
+ // State - The state of peering. Possible values are: 'Disabled' and 'Enabled'. Possible values include: 'ExpressRouteCircuitPeeringStateDisabled', 'ExpressRouteCircuitPeeringStateEnabled'
+ State ExpressRouteCircuitPeeringState `json:"state,omitempty"`
+ // AzureASN - The Azure ASN.
+ AzureASN *int32 `json:"azureASN,omitempty"`
+ // PeerASN - The peer ASN.
+ PeerASN *int64 `json:"peerASN,omitempty"`
+ // PrimaryPeerAddressPrefix - The primary address prefix.
+ PrimaryPeerAddressPrefix *string `json:"primaryPeerAddressPrefix,omitempty"`
+ // SecondaryPeerAddressPrefix - The secondary address prefix.
+ SecondaryPeerAddressPrefix *string `json:"secondaryPeerAddressPrefix,omitempty"`
+ // PrimaryAzurePort - The primary port.
+ PrimaryAzurePort *string `json:"primaryAzurePort,omitempty"`
+ // SecondaryAzurePort - The secondary port.
+ SecondaryAzurePort *string `json:"secondaryAzurePort,omitempty"`
+ // SharedKey - The shared key.
+ SharedKey *string `json:"sharedKey,omitempty"`
+ // VlanID - The VLAN ID.
+ VlanID *int32 `json:"vlanId,omitempty"`
+ // MicrosoftPeeringConfig - The Microsoft peering configuration.
+ MicrosoftPeeringConfig *ExpressRouteCircuitPeeringConfig `json:"microsoftPeeringConfig,omitempty"`
+ // Stats - Gets peering stats.
+ Stats *ExpressRouteCircuitStats `json:"stats,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // GatewayManagerEtag - The GatewayManager Etag.
+ GatewayManagerEtag *string `json:"gatewayManagerEtag,omitempty"`
+ // LastModifiedBy - Gets whether the provider or the customer last modified the peering.
+ LastModifiedBy *string `json:"lastModifiedBy,omitempty"`
+ // RouteFilter - The reference of the RouteFilter resource.
+ RouteFilter *RouteFilter `json:"routeFilter,omitempty"`
+ // Ipv6PeeringConfig - The IPv6 peering configuration.
+ Ipv6PeeringConfig *Ipv6ExpressRouteCircuitPeeringConfig `json:"ipv6PeeringConfig,omitempty"`
+}
+
+// ExpressRouteCircuitPeeringsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results
+// of a long-running operation.
+type ExpressRouteCircuitPeeringsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitPeeringsClient) (ExpressRouteCircuitPeering, error)
+}
+
+// ExpressRouteCircuitPeeringsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ExpressRouteCircuitPeeringsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitPeeringsClient) (autorest.Response, error)
+}
+
+// ExpressRouteCircuitPropertiesFormat properties of ExpressRouteCircuit.
+type ExpressRouteCircuitPropertiesFormat struct {
+ // AllowClassicOperations - Allow classic operations
+ AllowClassicOperations *bool `json:"allowClassicOperations,omitempty"`
+ // CircuitProvisioningState - The CircuitProvisioningState state of the resource.
+ CircuitProvisioningState *string `json:"circuitProvisioningState,omitempty"`
+ // ServiceProviderProvisioningState - The ServiceProviderProvisioningState state of the resource. Possible values are 'NotProvisioned', 'Provisioning', 'Provisioned', and 'Deprovisioning'. Possible values include: 'NotProvisioned', 'Provisioning', 'Provisioned', 'Deprovisioning'
+ ServiceProviderProvisioningState ServiceProviderProvisioningState `json:"serviceProviderProvisioningState,omitempty"`
+ // Authorizations - The list of authorizations.
+ Authorizations *[]ExpressRouteCircuitAuthorization `json:"authorizations,omitempty"`
+ // Peerings - The list of peerings.
+ Peerings *[]ExpressRouteCircuitPeering `json:"peerings,omitempty"`
+ // ServiceKey - The ServiceKey.
+ ServiceKey *string `json:"serviceKey,omitempty"`
+ // ServiceProviderNotes - The ServiceProviderNotes.
+ ServiceProviderNotes *string `json:"serviceProviderNotes,omitempty"`
+ // ServiceProviderProperties - The ServiceProviderProperties.
+ ServiceProviderProperties *ExpressRouteCircuitServiceProviderProperties `json:"serviceProviderProperties,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // GatewayManagerEtag - The GatewayManager Etag.
+ GatewayManagerEtag *string `json:"gatewayManagerEtag,omitempty"`
+}
+
+// ExpressRouteCircuitRoutesTable the routes table associated with the ExpressRouteCircuit
+type ExpressRouteCircuitRoutesTable struct {
+ // NetworkProperty - network
+ NetworkProperty *string `json:"network,omitempty"`
+ // NextHop - nextHop
+ NextHop *string `json:"nextHop,omitempty"`
+ // LocPrf - locPrf
+ LocPrf *string `json:"locPrf,omitempty"`
+ // Weight - weight.
+ Weight *int32 `json:"weight,omitempty"`
+ // Path - path
+ Path *string `json:"path,omitempty"`
+}
+
+// ExpressRouteCircuitRoutesTableSummary the routes table associated with the ExpressRouteCircuit.
+type ExpressRouteCircuitRoutesTableSummary struct {
+ // Neighbor - Neighbor
+ Neighbor *string `json:"neighbor,omitempty"`
+ // V - BGP version number spoken to the neighbor.
+ V *int32 `json:"v,omitempty"`
+ // As - Autonomous system number.
+ As *int32 `json:"as,omitempty"`
+ // UpDown - The length of time that the BGP session has been in the Established state, or the current status if not in the Established state.
+ UpDown *string `json:"upDown,omitempty"`
+ // StatePfxRcd - Current state of the BGP session, and the number of prefixes that have been received from a neighbor or peer group.
+ StatePfxRcd *string `json:"statePfxRcd,omitempty"`
+}
+
+// ExpressRouteCircuitsArpTableListResult response for ListArpTable associated with the Express Route
+// Circuits API.
+type ExpressRouteCircuitsArpTableListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets list of the ARP table.
+ Value *[]ExpressRouteCircuitArpTable `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ExpressRouteCircuitsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ExpressRouteCircuitsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitsClient) (ExpressRouteCircuit, error)
+}
+
+// ExpressRouteCircuitsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ExpressRouteCircuitsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitsClient) (autorest.Response, error)
+}
+
+// ExpressRouteCircuitServiceProviderProperties contains ServiceProviderProperties in an
+// ExpressRouteCircuit.
+type ExpressRouteCircuitServiceProviderProperties struct {
+ // ServiceProviderName - The serviceProviderName.
+ ServiceProviderName *string `json:"serviceProviderName,omitempty"`
+ // PeeringLocation - The peering location.
+ PeeringLocation *string `json:"peeringLocation,omitempty"`
+ // BandwidthInMbps - The BandwidthInMbps.
+ BandwidthInMbps *int32 `json:"bandwidthInMbps,omitempty"`
+}
+
+// ExpressRouteCircuitSku contains SKU in an ExpressRouteCircuit.
+type ExpressRouteCircuitSku struct {
+ // Name - The name of the SKU.
+ Name *string `json:"name,omitempty"`
+ // Tier - The tier of the SKU. Possible values are 'Standard' and 'Premium'. Possible values include: 'ExpressRouteCircuitSkuTierStandard', 'ExpressRouteCircuitSkuTierPremium'
+ Tier ExpressRouteCircuitSkuTier `json:"tier,omitempty"`
+ // Family - The family of the SKU. Possible values are: 'UnlimitedData' and 'MeteredData'. Possible values include: 'UnlimitedData', 'MeteredData'
+ Family ExpressRouteCircuitSkuFamily `json:"family,omitempty"`
+}
+
+// ExpressRouteCircuitsListArpTableFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ExpressRouteCircuitsListArpTableFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitsClient) (ExpressRouteCircuitsArpTableListResult, error)
+}
+
+// ExpressRouteCircuitsListRoutesTableFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ExpressRouteCircuitsListRoutesTableFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitsClient) (ExpressRouteCircuitsRoutesTableListResult, error)
+}
+
+// ExpressRouteCircuitsListRoutesTableSummaryFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type ExpressRouteCircuitsListRoutesTableSummaryFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitsClient) (ExpressRouteCircuitsRoutesTableSummaryListResult, error)
+}
+
+// ExpressRouteCircuitsRoutesTableListResult response for ListRoutesTable associated with the Express Route
+// Circuits API.
+type ExpressRouteCircuitsRoutesTableListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list of routes table.
+ Value *[]ExpressRouteCircuitRoutesTable `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ExpressRouteCircuitsRoutesTableSummaryListResult response for ListRoutesTable associated with the
+// Express Route Circuits API.
+type ExpressRouteCircuitsRoutesTableSummaryListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of the routes table.
+ Value *[]ExpressRouteCircuitRoutesTableSummary `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ExpressRouteCircuitStats contains stats associated with the peering.
+type ExpressRouteCircuitStats struct {
+ autorest.Response `json:"-"`
+ // PrimarybytesIn - Gets BytesIn of the peering.
+ PrimarybytesIn *int64 `json:"primarybytesIn,omitempty"`
+ // PrimarybytesOut - Gets BytesOut of the peering.
+ PrimarybytesOut *int64 `json:"primarybytesOut,omitempty"`
+ // SecondarybytesIn - Gets BytesIn of the peering.
+ SecondarybytesIn *int64 `json:"secondarybytesIn,omitempty"`
+ // SecondarybytesOut - Gets BytesOut of the peering.
+ SecondarybytesOut *int64 `json:"secondarybytesOut,omitempty"`
+}
+
+// ExpressRouteCircuitsUpdateTagsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type ExpressRouteCircuitsUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(ExpressRouteCircuitsClient) (ExpressRouteCircuit, error)
+}
+
+// ExpressRouteServiceProvider a ExpressRouteResourceProvider object.
+type ExpressRouteServiceProvider struct {
+ *ExpressRouteServiceProviderPropertiesFormat `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for ExpressRouteServiceProvider.
+func (ersp ExpressRouteServiceProvider) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ersp.ExpressRouteServiceProviderPropertiesFormat != nil {
+ objectMap["properties"] = ersp.ExpressRouteServiceProviderPropertiesFormat
+ }
+ if ersp.ID != nil {
+ objectMap["id"] = ersp.ID
+ }
+ if ersp.Location != nil {
+ objectMap["location"] = ersp.Location
+ }
+ if ersp.Tags != nil {
+ objectMap["tags"] = ersp.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ExpressRouteServiceProvider struct.
+func (ersp *ExpressRouteServiceProvider) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var expressRouteServiceProviderPropertiesFormat ExpressRouteServiceProviderPropertiesFormat
+ err = json.Unmarshal(*v, &expressRouteServiceProviderPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ ersp.ExpressRouteServiceProviderPropertiesFormat = &expressRouteServiceProviderPropertiesFormat
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ ersp.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ ersp.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ ersp.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ ersp.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ ersp.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// ExpressRouteServiceProviderBandwidthsOffered contains bandwidths offered in ExpressRouteServiceProvider
+// resources.
+type ExpressRouteServiceProviderBandwidthsOffered struct {
+ // OfferName - The OfferName.
+ OfferName *string `json:"offerName,omitempty"`
+ // ValueInMbps - The ValueInMbps.
+ ValueInMbps *int32 `json:"valueInMbps,omitempty"`
+}
+
+// ExpressRouteServiceProviderListResult response for the ListExpressRouteServiceProvider API service call.
+type ExpressRouteServiceProviderListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of ExpressRouteResourceProvider resources.
+ Value *[]ExpressRouteServiceProvider `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ExpressRouteServiceProviderListResultIterator provides access to a complete listing of
+// ExpressRouteServiceProvider values.
+type ExpressRouteServiceProviderListResultIterator struct {
+ i int
+ page ExpressRouteServiceProviderListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ExpressRouteServiceProviderListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteServiceProviderListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *ExpressRouteServiceProviderListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ExpressRouteServiceProviderListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ExpressRouteServiceProviderListResultIterator) Response() ExpressRouteServiceProviderListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ExpressRouteServiceProviderListResultIterator) Value() ExpressRouteServiceProvider {
+ if !iter.page.NotDone() {
+ return ExpressRouteServiceProvider{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the ExpressRouteServiceProviderListResultIterator type.
+func NewExpressRouteServiceProviderListResultIterator(page ExpressRouteServiceProviderListResultPage) ExpressRouteServiceProviderListResultIterator {
+ return ExpressRouteServiceProviderListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (ersplr ExpressRouteServiceProviderListResult) IsEmpty() bool {
+ return ersplr.Value == nil || len(*ersplr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (ersplr ExpressRouteServiceProviderListResult) hasNextLink() bool {
+ return ersplr.NextLink != nil && len(*ersplr.NextLink) != 0
+}
+
+// expressRouteServiceProviderListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (ersplr ExpressRouteServiceProviderListResult) expressRouteServiceProviderListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !ersplr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(ersplr.NextLink)))
+}
+
+// ExpressRouteServiceProviderListResultPage contains a page of ExpressRouteServiceProvider values.
+type ExpressRouteServiceProviderListResultPage struct {
+ fn func(context.Context, ExpressRouteServiceProviderListResult) (ExpressRouteServiceProviderListResult, error)
+ ersplr ExpressRouteServiceProviderListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ExpressRouteServiceProviderListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteServiceProviderListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.ersplr)
+ if err != nil {
+ return err
+ }
+ page.ersplr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *ExpressRouteServiceProviderListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ExpressRouteServiceProviderListResultPage) NotDone() bool {
+ return !page.ersplr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ExpressRouteServiceProviderListResultPage) Response() ExpressRouteServiceProviderListResult {
+ return page.ersplr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ExpressRouteServiceProviderListResultPage) Values() []ExpressRouteServiceProvider {
+ if page.ersplr.IsEmpty() {
+ return nil
+ }
+ return *page.ersplr.Value
+}
+
+// Creates a new instance of the ExpressRouteServiceProviderListResultPage type.
+func NewExpressRouteServiceProviderListResultPage(cur ExpressRouteServiceProviderListResult, getNextPage func(context.Context, ExpressRouteServiceProviderListResult) (ExpressRouteServiceProviderListResult, error)) ExpressRouteServiceProviderListResultPage {
+ return ExpressRouteServiceProviderListResultPage{
+ fn: getNextPage,
+ ersplr: cur,
+ }
+}
+
+// ExpressRouteServiceProviderPropertiesFormat properties of ExpressRouteServiceProvider.
+type ExpressRouteServiceProviderPropertiesFormat struct {
+ // PeeringLocations - Get a list of peering locations.
+ PeeringLocations *[]string `json:"peeringLocations,omitempty"`
+ // BandwidthsOffered - Gets bandwidths offered.
+ BandwidthsOffered *[]ExpressRouteServiceProviderBandwidthsOffered `json:"bandwidthsOffered,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the resource.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// FlowLogInformation information on the configuration of flow log.
+type FlowLogInformation struct {
+ autorest.Response `json:"-"`
+ // TargetResourceID - The ID of the resource to configure for flow logging.
+ TargetResourceID *string `json:"targetResourceId,omitempty"`
+ *FlowLogProperties `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for FlowLogInformation.
+func (fli FlowLogInformation) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if fli.TargetResourceID != nil {
+ objectMap["targetResourceId"] = fli.TargetResourceID
+ }
+ if fli.FlowLogProperties != nil {
+ objectMap["properties"] = fli.FlowLogProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for FlowLogInformation struct.
+func (fli *FlowLogInformation) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "targetResourceId":
+ if v != nil {
+ var targetResourceID string
+ err = json.Unmarshal(*v, &targetResourceID)
+ if err != nil {
+ return err
+ }
+ fli.TargetResourceID = &targetResourceID
+ }
+ case "properties":
+ if v != nil {
+ var flowLogProperties FlowLogProperties
+ err = json.Unmarshal(*v, &flowLogProperties)
+ if err != nil {
+ return err
+ }
+ fli.FlowLogProperties = &flowLogProperties
+ }
+ }
+ }
+
+ return nil
+}
+
+// FlowLogProperties parameters that define the configuration of flow log.
+type FlowLogProperties struct {
+ // StorageID - ID of the storage account which is used to store the flow log.
+ StorageID *string `json:"storageId,omitempty"`
+ // Enabled - Flag to enable/disable flow logging.
+ Enabled *bool `json:"enabled,omitempty"`
+ RetentionPolicy *RetentionPolicyParameters `json:"retentionPolicy,omitempty"`
+}
+
+// FlowLogStatusParameters parameters that define a resource to query flow log status.
+type FlowLogStatusParameters struct {
+ // TargetResourceID - The target resource where getting the flow logging status.
+ TargetResourceID *string `json:"targetResourceId,omitempty"`
+}
+
+// FrontendIPConfiguration frontend IP address of the load balancer.
+type FrontendIPConfiguration struct {
+ autorest.Response `json:"-"`
+ // FrontendIPConfigurationPropertiesFormat - Properties of the load balancer probe.
+ *FrontendIPConfigurationPropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Zones - A list of availability zones denoting the IP allocated for the resource needs to come from.
+ Zones *[]string `json:"zones,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for FrontendIPConfiguration.
+func (fic FrontendIPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if fic.FrontendIPConfigurationPropertiesFormat != nil {
+ objectMap["properties"] = fic.FrontendIPConfigurationPropertiesFormat
+ }
+ if fic.Name != nil {
+ objectMap["name"] = fic.Name
+ }
+ if fic.Etag != nil {
+ objectMap["etag"] = fic.Etag
+ }
+ if fic.Zones != nil {
+ objectMap["zones"] = fic.Zones
+ }
+ if fic.ID != nil {
+ objectMap["id"] = fic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for FrontendIPConfiguration struct.
+func (fic *FrontendIPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var frontendIPConfigurationPropertiesFormat FrontendIPConfigurationPropertiesFormat
+ err = json.Unmarshal(*v, &frontendIPConfigurationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ fic.FrontendIPConfigurationPropertiesFormat = &frontendIPConfigurationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ fic.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ fic.Etag = &etag
+ }
+ case "zones":
+ if v != nil {
+ var zones []string
+ err = json.Unmarshal(*v, &zones)
+ if err != nil {
+ return err
+ }
+ fic.Zones = &zones
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ fic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// FrontendIPConfigurationPropertiesFormat properties of Frontend IP Configuration of the load balancer.
+type FrontendIPConfigurationPropertiesFormat struct {
+ // InboundNatRules - READ-ONLY; Read only. Inbound rules URIs that use this frontend IP.
+ InboundNatRules *[]SubResource `json:"inboundNatRules,omitempty"`
+ // InboundNatPools - READ-ONLY; Read only. Inbound pools URIs that use this frontend IP.
+ InboundNatPools *[]SubResource `json:"inboundNatPools,omitempty"`
+ // OutboundNatRules - READ-ONLY; Read only. Outbound rules URIs that use this frontend IP.
+ OutboundNatRules *[]SubResource `json:"outboundNatRules,omitempty"`
+ // LoadBalancingRules - READ-ONLY; Gets load balancing rules URIs that use this frontend IP.
+ LoadBalancingRules *[]SubResource `json:"loadBalancingRules,omitempty"`
+ // PrivateIPAddress - The private IP address of the IP configuration.
+ PrivateIPAddress *string `json:"privateIPAddress,omitempty"`
+ // PrivateIPAllocationMethod - The Private IP allocation method. Possible values are: 'Static' and 'Dynamic'. Possible values include: 'Static', 'Dynamic'
+ PrivateIPAllocationMethod IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
+ // Subnet - The reference of the subnet resource.
+ Subnet *Subnet `json:"subnet,omitempty"`
+ // PublicIPAddress - The reference of the Public IP resource.
+ PublicIPAddress *PublicIPAddress `json:"publicIPAddress,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for FrontendIPConfigurationPropertiesFormat.
+func (ficpf FrontendIPConfigurationPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ficpf.PrivateIPAddress != nil {
+ objectMap["privateIPAddress"] = ficpf.PrivateIPAddress
+ }
+ if ficpf.PrivateIPAllocationMethod != "" {
+ objectMap["privateIPAllocationMethod"] = ficpf.PrivateIPAllocationMethod
+ }
+ if ficpf.Subnet != nil {
+ objectMap["subnet"] = ficpf.Subnet
+ }
+ if ficpf.PublicIPAddress != nil {
+ objectMap["publicIPAddress"] = ficpf.PublicIPAddress
+ }
+ if ficpf.ProvisioningState != nil {
+ objectMap["provisioningState"] = ficpf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// GatewayRoute gateway routing details
+type GatewayRoute struct {
+ // LocalAddress - READ-ONLY; The gateway's local address
+ LocalAddress *string `json:"localAddress,omitempty"`
+ // NetworkProperty - READ-ONLY; The route's network prefix
+ NetworkProperty *string `json:"network,omitempty"`
+ // NextHop - READ-ONLY; The route's next hop
+ NextHop *string `json:"nextHop,omitempty"`
+ // SourcePeer - READ-ONLY; The peer this route was learned from
+ SourcePeer *string `json:"sourcePeer,omitempty"`
+ // Origin - READ-ONLY; The source this route was learned from
+ Origin *string `json:"origin,omitempty"`
+ // AsPath - READ-ONLY; The route's AS path sequence
+ AsPath *string `json:"asPath,omitempty"`
+ // Weight - READ-ONLY; The route's weight
+ Weight *int32 `json:"weight,omitempty"`
+}
+
+// GatewayRouteListResult list of virtual network gateway routes
+type GatewayRouteListResult struct {
+ autorest.Response `json:"-"`
+ // Value - List of gateway routes
+ Value *[]GatewayRoute `json:"value,omitempty"`
+}
+
+// InboundNatPool inbound NAT pool of the load balancer.
+type InboundNatPool struct {
+ // InboundNatPoolPropertiesFormat - Properties of load balancer inbound nat pool.
+ *InboundNatPoolPropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InboundNatPool.
+func (inp InboundNatPool) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if inp.InboundNatPoolPropertiesFormat != nil {
+ objectMap["properties"] = inp.InboundNatPoolPropertiesFormat
+ }
+ if inp.Name != nil {
+ objectMap["name"] = inp.Name
+ }
+ if inp.Etag != nil {
+ objectMap["etag"] = inp.Etag
+ }
+ if inp.ID != nil {
+ objectMap["id"] = inp.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for InboundNatPool struct.
+func (inp *InboundNatPool) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var inboundNatPoolPropertiesFormat InboundNatPoolPropertiesFormat
+ err = json.Unmarshal(*v, &inboundNatPoolPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ inp.InboundNatPoolPropertiesFormat = &inboundNatPoolPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ inp.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ inp.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ inp.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// InboundNatPoolPropertiesFormat properties of Inbound NAT pool.
+type InboundNatPoolPropertiesFormat struct {
+ // FrontendIPConfiguration - A reference to frontend IP addresses.
+ FrontendIPConfiguration *SubResource `json:"frontendIPConfiguration,omitempty"`
+ // Protocol - Possible values include: 'TransportProtocolUDP', 'TransportProtocolTCP', 'TransportProtocolAll'
+ Protocol TransportProtocol `json:"protocol,omitempty"`
+ // FrontendPortRangeStart - The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65534.
+ FrontendPortRangeStart *int32 `json:"frontendPortRangeStart,omitempty"`
+ // FrontendPortRangeEnd - The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65535.
+ FrontendPortRangeEnd *int32 `json:"frontendPortRangeEnd,omitempty"`
+ // BackendPort - The port used for internal connections on the endpoint. Acceptable values are between 1 and 65535.
+ BackendPort *int32 `json:"backendPort,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// InboundNatRule inbound NAT rule of the load balancer.
+type InboundNatRule struct {
+ autorest.Response `json:"-"`
+ // InboundNatRulePropertiesFormat - Properties of load balancer inbound nat rule.
+ *InboundNatRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InboundNatRule.
+func (inr InboundNatRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if inr.InboundNatRulePropertiesFormat != nil {
+ objectMap["properties"] = inr.InboundNatRulePropertiesFormat
+ }
+ if inr.Name != nil {
+ objectMap["name"] = inr.Name
+ }
+ if inr.Etag != nil {
+ objectMap["etag"] = inr.Etag
+ }
+ if inr.ID != nil {
+ objectMap["id"] = inr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for InboundNatRule struct.
+func (inr *InboundNatRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var inboundNatRulePropertiesFormat InboundNatRulePropertiesFormat
+ err = json.Unmarshal(*v, &inboundNatRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ inr.InboundNatRulePropertiesFormat = &inboundNatRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ inr.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ inr.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ inr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// InboundNatRuleListResult response for ListInboundNatRule API service call.
+type InboundNatRuleListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of inbound nat rules in a load balancer.
+ Value *[]InboundNatRule `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InboundNatRuleListResult.
+func (inrlr InboundNatRuleListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if inrlr.Value != nil {
+ objectMap["value"] = inrlr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// InboundNatRuleListResultIterator provides access to a complete listing of InboundNatRule values.
+type InboundNatRuleListResultIterator struct {
+ i int
+ page InboundNatRuleListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *InboundNatRuleListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InboundNatRuleListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *InboundNatRuleListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter InboundNatRuleListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter InboundNatRuleListResultIterator) Response() InboundNatRuleListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter InboundNatRuleListResultIterator) Value() InboundNatRule {
+ if !iter.page.NotDone() {
+ return InboundNatRule{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the InboundNatRuleListResultIterator type.
+func NewInboundNatRuleListResultIterator(page InboundNatRuleListResultPage) InboundNatRuleListResultIterator {
+ return InboundNatRuleListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (inrlr InboundNatRuleListResult) IsEmpty() bool {
+ return inrlr.Value == nil || len(*inrlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (inrlr InboundNatRuleListResult) hasNextLink() bool {
+ return inrlr.NextLink != nil && len(*inrlr.NextLink) != 0
+}
+
+// inboundNatRuleListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (inrlr InboundNatRuleListResult) inboundNatRuleListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !inrlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(inrlr.NextLink)))
+}
+
+// InboundNatRuleListResultPage contains a page of InboundNatRule values.
+type InboundNatRuleListResultPage struct {
+ fn func(context.Context, InboundNatRuleListResult) (InboundNatRuleListResult, error)
+ inrlr InboundNatRuleListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *InboundNatRuleListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InboundNatRuleListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.inrlr)
+ if err != nil {
+ return err
+ }
+ page.inrlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *InboundNatRuleListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page InboundNatRuleListResultPage) NotDone() bool {
+ return !page.inrlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page InboundNatRuleListResultPage) Response() InboundNatRuleListResult {
+ return page.inrlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page InboundNatRuleListResultPage) Values() []InboundNatRule {
+ if page.inrlr.IsEmpty() {
+ return nil
+ }
+ return *page.inrlr.Value
+}
+
+// Creates a new instance of the InboundNatRuleListResultPage type.
+func NewInboundNatRuleListResultPage(cur InboundNatRuleListResult, getNextPage func(context.Context, InboundNatRuleListResult) (InboundNatRuleListResult, error)) InboundNatRuleListResultPage {
+ return InboundNatRuleListResultPage{
+ fn: getNextPage,
+ inrlr: cur,
+ }
+}
+
+// InboundNatRulePropertiesFormat properties of the inbound NAT rule.
+type InboundNatRulePropertiesFormat struct {
+ // FrontendIPConfiguration - A reference to frontend IP addresses.
+ FrontendIPConfiguration *SubResource `json:"frontendIPConfiguration,omitempty"`
+ // BackendIPConfiguration - READ-ONLY; A reference to a private IP address defined on a network interface of a VM. Traffic sent to the frontend port of each of the frontend IP configurations is forwarded to the backend IP.
+ BackendIPConfiguration *InterfaceIPConfiguration `json:"backendIPConfiguration,omitempty"`
+ // Protocol - Possible values include: 'TransportProtocolUDP', 'TransportProtocolTCP', 'TransportProtocolAll'
+ Protocol TransportProtocol `json:"protocol,omitempty"`
+ // FrontendPort - The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values range from 1 to 65534.
+ FrontendPort *int32 `json:"frontendPort,omitempty"`
+ // BackendPort - The port used for the internal endpoint. Acceptable values range from 1 to 65535.
+ BackendPort *int32 `json:"backendPort,omitempty"`
+ // IdleTimeoutInMinutes - The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
+ IdleTimeoutInMinutes *int32 `json:"idleTimeoutInMinutes,omitempty"`
+ // EnableFloatingIP - Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
+ EnableFloatingIP *bool `json:"enableFloatingIP,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InboundNatRulePropertiesFormat.
+func (inrpf InboundNatRulePropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if inrpf.FrontendIPConfiguration != nil {
+ objectMap["frontendIPConfiguration"] = inrpf.FrontendIPConfiguration
+ }
+ if inrpf.Protocol != "" {
+ objectMap["protocol"] = inrpf.Protocol
+ }
+ if inrpf.FrontendPort != nil {
+ objectMap["frontendPort"] = inrpf.FrontendPort
+ }
+ if inrpf.BackendPort != nil {
+ objectMap["backendPort"] = inrpf.BackendPort
+ }
+ if inrpf.IdleTimeoutInMinutes != nil {
+ objectMap["idleTimeoutInMinutes"] = inrpf.IdleTimeoutInMinutes
+ }
+ if inrpf.EnableFloatingIP != nil {
+ objectMap["enableFloatingIP"] = inrpf.EnableFloatingIP
+ }
+ if inrpf.ProvisioningState != nil {
+ objectMap["provisioningState"] = inrpf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// InboundNatRulesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type InboundNatRulesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(InboundNatRulesClient) (InboundNatRule, error)
+}
+
+// InboundNatRulesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type InboundNatRulesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(InboundNatRulesClient) (autorest.Response, error)
+}
+
+// Interface a network interface in a resource group.
+type Interface struct {
+ autorest.Response `json:"-"`
+ // InterfacePropertiesFormat - Properties of the network interface.
+ *InterfacePropertiesFormat `json:"properties,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Interface.
+func (i Interface) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if i.InterfacePropertiesFormat != nil {
+ objectMap["properties"] = i.InterfacePropertiesFormat
+ }
+ if i.Etag != nil {
+ objectMap["etag"] = i.Etag
+ }
+ if i.ID != nil {
+ objectMap["id"] = i.ID
+ }
+ if i.Location != nil {
+ objectMap["location"] = i.Location
+ }
+ if i.Tags != nil {
+ objectMap["tags"] = i.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Interface struct.
+func (i *Interface) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var interfacePropertiesFormat InterfacePropertiesFormat
+ err = json.Unmarshal(*v, &interfacePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ i.InterfacePropertiesFormat = &interfacePropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ i.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ i.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ i.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ i.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ i.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ i.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// InterfaceAssociation network interface and its custom security rules.
+type InterfaceAssociation struct {
+ // ID - READ-ONLY; Network interface ID.
+ ID *string `json:"id,omitempty"`
+ // SecurityRules - Collection of custom security rules.
+ SecurityRules *[]SecurityRule `json:"securityRules,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InterfaceAssociation.
+func (ia InterfaceAssociation) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ia.SecurityRules != nil {
+ objectMap["securityRules"] = ia.SecurityRules
+ }
+ return json.Marshal(objectMap)
+}
+
+// InterfaceDNSSettings DNS settings of a network interface.
+type InterfaceDNSSettings struct {
+ // DNSServers - List of DNS servers IP addresses. Use 'AzureProvidedDNS' to switch to azure provided DNS resolution. 'AzureProvidedDNS' value cannot be combined with other IPs, it must be the only value in dnsServers collection.
+ DNSServers *[]string `json:"dnsServers,omitempty"`
+ // AppliedDNSServers - If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set. This property is what is configured on each of those VMs.
+ AppliedDNSServers *[]string `json:"appliedDnsServers,omitempty"`
+ // InternalDNSNameLabel - Relative DNS name for this NIC used for internal communications between VMs in the same virtual network.
+ InternalDNSNameLabel *string `json:"internalDnsNameLabel,omitempty"`
+ // InternalFqdn - Fully qualified DNS name supporting internal communications between VMs in the same virtual network.
+ InternalFqdn *string `json:"internalFqdn,omitempty"`
+ // InternalDomainNameSuffix - Even if internalDnsNameLabel is not specified, a DNS entry is created for the primary NIC of the VM. This DNS name can be constructed by concatenating the VM name with the value of internalDomainNameSuffix.
+ InternalDomainNameSuffix *string `json:"internalDomainNameSuffix,omitempty"`
+}
+
+// InterfaceIPConfiguration iPConfiguration in a network interface.
+type InterfaceIPConfiguration struct {
+ autorest.Response `json:"-"`
+ // InterfaceIPConfigurationPropertiesFormat - Network interface IP configuration properties.
+ *InterfaceIPConfigurationPropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InterfaceIPConfiguration.
+func (iic InterfaceIPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if iic.InterfaceIPConfigurationPropertiesFormat != nil {
+ objectMap["properties"] = iic.InterfaceIPConfigurationPropertiesFormat
+ }
+ if iic.Name != nil {
+ objectMap["name"] = iic.Name
+ }
+ if iic.Etag != nil {
+ objectMap["etag"] = iic.Etag
+ }
+ if iic.ID != nil {
+ objectMap["id"] = iic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for InterfaceIPConfiguration struct.
+func (iic *InterfaceIPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var interfaceIPConfigurationPropertiesFormat InterfaceIPConfigurationPropertiesFormat
+ err = json.Unmarshal(*v, &interfaceIPConfigurationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ iic.InterfaceIPConfigurationPropertiesFormat = &interfaceIPConfigurationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ iic.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ iic.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ iic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// InterfaceIPConfigurationListResult response for list ip configurations API service call.
+type InterfaceIPConfigurationListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of ip configurations.
+ Value *[]InterfaceIPConfiguration `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InterfaceIPConfigurationListResult.
+func (iiclr InterfaceIPConfigurationListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if iiclr.Value != nil {
+ objectMap["value"] = iiclr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// InterfaceIPConfigurationListResultIterator provides access to a complete listing of
+// InterfaceIPConfiguration values.
+type InterfaceIPConfigurationListResultIterator struct {
+ i int
+ page InterfaceIPConfigurationListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *InterfaceIPConfigurationListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceIPConfigurationListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *InterfaceIPConfigurationListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter InterfaceIPConfigurationListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter InterfaceIPConfigurationListResultIterator) Response() InterfaceIPConfigurationListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter InterfaceIPConfigurationListResultIterator) Value() InterfaceIPConfiguration {
+ if !iter.page.NotDone() {
+ return InterfaceIPConfiguration{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the InterfaceIPConfigurationListResultIterator type.
+func NewInterfaceIPConfigurationListResultIterator(page InterfaceIPConfigurationListResultPage) InterfaceIPConfigurationListResultIterator {
+ return InterfaceIPConfigurationListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (iiclr InterfaceIPConfigurationListResult) IsEmpty() bool {
+ return iiclr.Value == nil || len(*iiclr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (iiclr InterfaceIPConfigurationListResult) hasNextLink() bool {
+ return iiclr.NextLink != nil && len(*iiclr.NextLink) != 0
+}
+
+// interfaceIPConfigurationListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (iiclr InterfaceIPConfigurationListResult) interfaceIPConfigurationListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !iiclr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(iiclr.NextLink)))
+}
+
+// InterfaceIPConfigurationListResultPage contains a page of InterfaceIPConfiguration values.
+type InterfaceIPConfigurationListResultPage struct {
+ fn func(context.Context, InterfaceIPConfigurationListResult) (InterfaceIPConfigurationListResult, error)
+ iiclr InterfaceIPConfigurationListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *InterfaceIPConfigurationListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceIPConfigurationListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.iiclr)
+ if err != nil {
+ return err
+ }
+ page.iiclr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *InterfaceIPConfigurationListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page InterfaceIPConfigurationListResultPage) NotDone() bool {
+ return !page.iiclr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page InterfaceIPConfigurationListResultPage) Response() InterfaceIPConfigurationListResult {
+ return page.iiclr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page InterfaceIPConfigurationListResultPage) Values() []InterfaceIPConfiguration {
+ if page.iiclr.IsEmpty() {
+ return nil
+ }
+ return *page.iiclr.Value
+}
+
+// Creates a new instance of the InterfaceIPConfigurationListResultPage type.
+func NewInterfaceIPConfigurationListResultPage(cur InterfaceIPConfigurationListResult, getNextPage func(context.Context, InterfaceIPConfigurationListResult) (InterfaceIPConfigurationListResult, error)) InterfaceIPConfigurationListResultPage {
+ return InterfaceIPConfigurationListResultPage{
+ fn: getNextPage,
+ iiclr: cur,
+ }
+}
+
+// InterfaceIPConfigurationPropertiesFormat properties of IP configuration.
+type InterfaceIPConfigurationPropertiesFormat struct {
+ // ApplicationGatewayBackendAddressPools - The reference of ApplicationGatewayBackendAddressPool resource.
+ ApplicationGatewayBackendAddressPools *[]ApplicationGatewayBackendAddressPool `json:"applicationGatewayBackendAddressPools,omitempty"`
+ // LoadBalancerBackendAddressPools - The reference of LoadBalancerBackendAddressPool resource.
+ LoadBalancerBackendAddressPools *[]BackendAddressPool `json:"loadBalancerBackendAddressPools,omitempty"`
+ // LoadBalancerInboundNatRules - A list of references of LoadBalancerInboundNatRules.
+ LoadBalancerInboundNatRules *[]InboundNatRule `json:"loadBalancerInboundNatRules,omitempty"`
+ // PrivateIPAddress - Private IP address of the IP configuration.
+ PrivateIPAddress *string `json:"privateIPAddress,omitempty"`
+ // PrivateIPAllocationMethod - Defines how a private IP address is assigned. Possible values are: 'Static' and 'Dynamic'. Possible values include: 'Static', 'Dynamic'
+ PrivateIPAllocationMethod IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
+ // PrivateIPAddressVersion - Available from Api-Version 2016-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'. Possible values include: 'IPv4', 'IPv6'
+ PrivateIPAddressVersion IPVersion `json:"privateIPAddressVersion,omitempty"`
+ // Subnet - Subnet bound to the IP configuration.
+ Subnet *Subnet `json:"subnet,omitempty"`
+ // Primary - Gets whether this is a primary customer address on the network interface.
+ Primary *bool `json:"primary,omitempty"`
+ // PublicIPAddress - Public IP address bound to the IP configuration.
+ PublicIPAddress *PublicIPAddress `json:"publicIPAddress,omitempty"`
+ // ApplicationSecurityGroups - Application security groups in which the IP configuration is included.
+ ApplicationSecurityGroups *[]ApplicationSecurityGroup `json:"applicationSecurityGroups,omitempty"`
+ // ProvisioningState - The provisioning state of the network interface IP configuration. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// InterfaceListResult response for the ListNetworkInterface API service call.
+type InterfaceListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of network interfaces in a resource group.
+ Value *[]Interface `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InterfaceListResult.
+func (ilr InterfaceListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ilr.Value != nil {
+ objectMap["value"] = ilr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// InterfaceListResultIterator provides access to a complete listing of Interface values.
+type InterfaceListResultIterator struct {
+ i int
+ page InterfaceListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *InterfaceListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *InterfaceListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter InterfaceListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter InterfaceListResultIterator) Response() InterfaceListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter InterfaceListResultIterator) Value() Interface {
+ if !iter.page.NotDone() {
+ return Interface{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the InterfaceListResultIterator type.
+func NewInterfaceListResultIterator(page InterfaceListResultPage) InterfaceListResultIterator {
+ return InterfaceListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (ilr InterfaceListResult) IsEmpty() bool {
+ return ilr.Value == nil || len(*ilr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (ilr InterfaceListResult) hasNextLink() bool {
+ return ilr.NextLink != nil && len(*ilr.NextLink) != 0
+}
+
+// interfaceListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (ilr InterfaceListResult) interfaceListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !ilr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(ilr.NextLink)))
+}
+
+// InterfaceListResultPage contains a page of Interface values.
+type InterfaceListResultPage struct {
+ fn func(context.Context, InterfaceListResult) (InterfaceListResult, error)
+ ilr InterfaceListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *InterfaceListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.ilr)
+ if err != nil {
+ return err
+ }
+ page.ilr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *InterfaceListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page InterfaceListResultPage) NotDone() bool {
+ return !page.ilr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page InterfaceListResultPage) Response() InterfaceListResult {
+ return page.ilr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page InterfaceListResultPage) Values() []Interface {
+ if page.ilr.IsEmpty() {
+ return nil
+ }
+ return *page.ilr.Value
+}
+
+// Creates a new instance of the InterfaceListResultPage type.
+func NewInterfaceListResultPage(cur InterfaceListResult, getNextPage func(context.Context, InterfaceListResult) (InterfaceListResult, error)) InterfaceListResultPage {
+ return InterfaceListResultPage{
+ fn: getNextPage,
+ ilr: cur,
+ }
+}
+
+// InterfaceLoadBalancerListResult response for list ip configurations API service call.
+type InterfaceLoadBalancerListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of load balancers.
+ Value *[]LoadBalancer `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for InterfaceLoadBalancerListResult.
+func (ilblr InterfaceLoadBalancerListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ilblr.Value != nil {
+ objectMap["value"] = ilblr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// InterfaceLoadBalancerListResultIterator provides access to a complete listing of LoadBalancer values.
+type InterfaceLoadBalancerListResultIterator struct {
+ i int
+ page InterfaceLoadBalancerListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *InterfaceLoadBalancerListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceLoadBalancerListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *InterfaceLoadBalancerListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter InterfaceLoadBalancerListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter InterfaceLoadBalancerListResultIterator) Response() InterfaceLoadBalancerListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter InterfaceLoadBalancerListResultIterator) Value() LoadBalancer {
+ if !iter.page.NotDone() {
+ return LoadBalancer{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the InterfaceLoadBalancerListResultIterator type.
+func NewInterfaceLoadBalancerListResultIterator(page InterfaceLoadBalancerListResultPage) InterfaceLoadBalancerListResultIterator {
+ return InterfaceLoadBalancerListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (ilblr InterfaceLoadBalancerListResult) IsEmpty() bool {
+ return ilblr.Value == nil || len(*ilblr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (ilblr InterfaceLoadBalancerListResult) hasNextLink() bool {
+ return ilblr.NextLink != nil && len(*ilblr.NextLink) != 0
+}
+
+// interfaceLoadBalancerListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (ilblr InterfaceLoadBalancerListResult) interfaceLoadBalancerListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !ilblr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(ilblr.NextLink)))
+}
+
+// InterfaceLoadBalancerListResultPage contains a page of LoadBalancer values.
+type InterfaceLoadBalancerListResultPage struct {
+ fn func(context.Context, InterfaceLoadBalancerListResult) (InterfaceLoadBalancerListResult, error)
+ ilblr InterfaceLoadBalancerListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *InterfaceLoadBalancerListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/InterfaceLoadBalancerListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.ilblr)
+ if err != nil {
+ return err
+ }
+ page.ilblr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *InterfaceLoadBalancerListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page InterfaceLoadBalancerListResultPage) NotDone() bool {
+ return !page.ilblr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page InterfaceLoadBalancerListResultPage) Response() InterfaceLoadBalancerListResult {
+ return page.ilblr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page InterfaceLoadBalancerListResultPage) Values() []LoadBalancer {
+ if page.ilblr.IsEmpty() {
+ return nil
+ }
+ return *page.ilblr.Value
+}
+
+// Creates a new instance of the InterfaceLoadBalancerListResultPage type.
+func NewInterfaceLoadBalancerListResultPage(cur InterfaceLoadBalancerListResult, getNextPage func(context.Context, InterfaceLoadBalancerListResult) (InterfaceLoadBalancerListResult, error)) InterfaceLoadBalancerListResultPage {
+ return InterfaceLoadBalancerListResultPage{
+ fn: getNextPage,
+ ilblr: cur,
+ }
+}
+
+// InterfacePropertiesFormat networkInterface properties.
+type InterfacePropertiesFormat struct {
+ // VirtualMachine - The reference of a virtual machine.
+ VirtualMachine *SubResource `json:"virtualMachine,omitempty"`
+ // NetworkSecurityGroup - The reference of the NetworkSecurityGroup resource.
+ NetworkSecurityGroup *SecurityGroup `json:"networkSecurityGroup,omitempty"`
+ // IPConfigurations - A list of IPConfigurations of the network interface.
+ IPConfigurations *[]InterfaceIPConfiguration `json:"ipConfigurations,omitempty"`
+ // DNSSettings - The DNS settings in network interface.
+ DNSSettings *InterfaceDNSSettings `json:"dnsSettings,omitempty"`
+ // MacAddress - The MAC address of the network interface.
+ MacAddress *string `json:"macAddress,omitempty"`
+ // Primary - Gets whether this is a primary network interface on a virtual machine.
+ Primary *bool `json:"primary,omitempty"`
+ // EnableAcceleratedNetworking - If the network interface is accelerated networking enabled.
+ EnableAcceleratedNetworking *bool `json:"enableAcceleratedNetworking,omitempty"`
+ // EnableIPForwarding - Indicates whether IP forwarding is enabled on this network interface.
+ EnableIPForwarding *bool `json:"enableIPForwarding,omitempty"`
+ // ResourceGUID - The resource GUID property of the network interface resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// InterfacesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type InterfacesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(InterfacesClient) (Interface, error)
+}
+
+// InterfacesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type InterfacesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(InterfacesClient) (autorest.Response, error)
+}
+
+// InterfacesGetEffectiveRouteTableFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type InterfacesGetEffectiveRouteTableFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(InterfacesClient) (EffectiveRouteListResult, error)
+}
+
+// InterfacesListEffectiveNetworkSecurityGroupsFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type InterfacesListEffectiveNetworkSecurityGroupsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(InterfacesClient) (EffectiveNetworkSecurityGroupListResult, error)
+}
+
+// InterfacesUpdateTagsFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type InterfacesUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(InterfacesClient) (Interface, error)
+}
+
+// IPAddressAvailabilityResult response for CheckIPAddressAvailability API service call
+type IPAddressAvailabilityResult struct {
+ autorest.Response `json:"-"`
+ // Available - Private IP address availability.
+ Available *bool `json:"available,omitempty"`
+ // AvailableIPAddresses - Contains other available private IP addresses if the asked for address is taken.
+ AvailableIPAddresses *[]string `json:"availableIPAddresses,omitempty"`
+}
+
+// IPConfiguration IP configuration
+type IPConfiguration struct {
+ // IPConfigurationPropertiesFormat - Properties of the IP configuration
+ *IPConfigurationPropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for IPConfiguration.
+func (ic IPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ic.IPConfigurationPropertiesFormat != nil {
+ objectMap["properties"] = ic.IPConfigurationPropertiesFormat
+ }
+ if ic.Name != nil {
+ objectMap["name"] = ic.Name
+ }
+ if ic.Etag != nil {
+ objectMap["etag"] = ic.Etag
+ }
+ if ic.ID != nil {
+ objectMap["id"] = ic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for IPConfiguration struct.
+func (ic *IPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var IPConfigurationPropertiesFormat IPConfigurationPropertiesFormat
+ err = json.Unmarshal(*v, &IPConfigurationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ ic.IPConfigurationPropertiesFormat = &IPConfigurationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ ic.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ ic.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ ic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// IPConfigurationPropertiesFormat properties of IP configuration.
+type IPConfigurationPropertiesFormat struct {
+ // PrivateIPAddress - The private IP address of the IP configuration.
+ PrivateIPAddress *string `json:"privateIPAddress,omitempty"`
+ // PrivateIPAllocationMethod - The private IP allocation method. Possible values are 'Static' and 'Dynamic'. Possible values include: 'Static', 'Dynamic'
+ PrivateIPAllocationMethod IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
+ // Subnet - The reference of the subnet resource.
+ Subnet *Subnet `json:"subnet,omitempty"`
+ // PublicIPAddress - The reference of the public IP resource.
+ PublicIPAddress *PublicIPAddress `json:"publicIPAddress,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// IpsecPolicy an IPSec Policy configuration for a virtual network gateway connection
+type IpsecPolicy struct {
+ // SaLifeTimeSeconds - The IPSec Security Association (also called Quick Mode or Phase 2 SA) lifetime in seconds for a site to site VPN tunnel.
+ SaLifeTimeSeconds *int32 `json:"saLifeTimeSeconds,omitempty"`
+ // SaDataSizeKilobytes - The IPSec Security Association (also called Quick Mode or Phase 2 SA) payload size in KB for a site to site VPN tunnel.
+ SaDataSizeKilobytes *int32 `json:"saDataSizeKilobytes,omitempty"`
+ // IpsecEncryption - The IPSec encryption algorithm (IKE phase 1). Possible values include: 'IpsecEncryptionNone', 'IpsecEncryptionDES', 'IpsecEncryptionDES3', 'IpsecEncryptionAES128', 'IpsecEncryptionAES192', 'IpsecEncryptionAES256', 'IpsecEncryptionGCMAES128', 'IpsecEncryptionGCMAES192', 'IpsecEncryptionGCMAES256'
+ IpsecEncryption IpsecEncryption `json:"ipsecEncryption,omitempty"`
+ // IpsecIntegrity - The IPSec integrity algorithm (IKE phase 1). Possible values include: 'IpsecIntegrityMD5', 'IpsecIntegritySHA1', 'IpsecIntegritySHA256', 'IpsecIntegrityGCMAES128', 'IpsecIntegrityGCMAES192', 'IpsecIntegrityGCMAES256'
+ IpsecIntegrity IpsecIntegrity `json:"ipsecIntegrity,omitempty"`
+ // IkeEncryption - The IKE encryption algorithm (IKE phase 2). Possible values include: 'DES', 'DES3', 'AES128', 'AES192', 'AES256'
+ IkeEncryption IkeEncryption `json:"ikeEncryption,omitempty"`
+ // IkeIntegrity - The IKE integrity algorithm (IKE phase 2). Possible values include: 'MD5', 'SHA1', 'SHA256', 'SHA384'
+ IkeIntegrity IkeIntegrity `json:"ikeIntegrity,omitempty"`
+ // DhGroup - The DH Groups used in IKE Phase 1 for initial SA. Possible values include: 'None', 'DHGroup1', 'DHGroup2', 'DHGroup14', 'DHGroup2048', 'ECP256', 'ECP384', 'DHGroup24'
+ DhGroup DhGroup `json:"dhGroup,omitempty"`
+ // PfsGroup - The DH Groups used in IKE Phase 2 for new child SA. Possible values include: 'PfsGroupNone', 'PfsGroupPFS1', 'PfsGroupPFS2', 'PfsGroupPFS2048', 'PfsGroupECP256', 'PfsGroupECP384', 'PfsGroupPFS24'
+ PfsGroup PfsGroup `json:"pfsGroup,omitempty"`
+}
+
+// Ipv6ExpressRouteCircuitPeeringConfig contains IPv6 peering config.
+type Ipv6ExpressRouteCircuitPeeringConfig struct {
+ // PrimaryPeerAddressPrefix - The primary address prefix.
+ PrimaryPeerAddressPrefix *string `json:"primaryPeerAddressPrefix,omitempty"`
+ // SecondaryPeerAddressPrefix - The secondary address prefix.
+ SecondaryPeerAddressPrefix *string `json:"secondaryPeerAddressPrefix,omitempty"`
+ // MicrosoftPeeringConfig - The Microsoft peering configuration.
+ MicrosoftPeeringConfig *ExpressRouteCircuitPeeringConfig `json:"microsoftPeeringConfig,omitempty"`
+ // RouteFilter - The reference of the RouteFilter resource.
+ RouteFilter *RouteFilter `json:"routeFilter,omitempty"`
+ // State - The state of peering. Possible values are: 'Disabled' and 'Enabled'. Possible values include: 'ExpressRouteCircuitPeeringStateDisabled', 'ExpressRouteCircuitPeeringStateEnabled'
+ State ExpressRouteCircuitPeeringState `json:"state,omitempty"`
+}
+
+// LoadBalancer loadBalancer resource
+type LoadBalancer struct {
+ autorest.Response `json:"-"`
+ // Sku - The load balancer SKU.
+ Sku *LoadBalancerSku `json:"sku,omitempty"`
+ // LoadBalancerPropertiesFormat - Properties of load balancer.
+ *LoadBalancerPropertiesFormat `json:"properties,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for LoadBalancer.
+func (lb LoadBalancer) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lb.Sku != nil {
+ objectMap["sku"] = lb.Sku
+ }
+ if lb.LoadBalancerPropertiesFormat != nil {
+ objectMap["properties"] = lb.LoadBalancerPropertiesFormat
+ }
+ if lb.Etag != nil {
+ objectMap["etag"] = lb.Etag
+ }
+ if lb.ID != nil {
+ objectMap["id"] = lb.ID
+ }
+ if lb.Location != nil {
+ objectMap["location"] = lb.Location
+ }
+ if lb.Tags != nil {
+ objectMap["tags"] = lb.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for LoadBalancer struct.
+func (lb *LoadBalancer) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku LoadBalancerSku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ lb.Sku = &sku
+ }
+ case "properties":
+ if v != nil {
+ var loadBalancerPropertiesFormat LoadBalancerPropertiesFormat
+ err = json.Unmarshal(*v, &loadBalancerPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ lb.LoadBalancerPropertiesFormat = &loadBalancerPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ lb.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ lb.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ lb.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ lb.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ lb.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ lb.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// LoadBalancerBackendAddressPoolListResult response for ListBackendAddressPool API service call.
+type LoadBalancerBackendAddressPoolListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of backend address pools in a load balancer.
+ Value *[]BackendAddressPool `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LoadBalancerBackendAddressPoolListResult.
+func (lbbaplr LoadBalancerBackendAddressPoolListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lbbaplr.Value != nil {
+ objectMap["value"] = lbbaplr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// LoadBalancerBackendAddressPoolListResultIterator provides access to a complete listing of
+// BackendAddressPool values.
+type LoadBalancerBackendAddressPoolListResultIterator struct {
+ i int
+ page LoadBalancerBackendAddressPoolListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *LoadBalancerBackendAddressPoolListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerBackendAddressPoolListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *LoadBalancerBackendAddressPoolListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter LoadBalancerBackendAddressPoolListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter LoadBalancerBackendAddressPoolListResultIterator) Response() LoadBalancerBackendAddressPoolListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter LoadBalancerBackendAddressPoolListResultIterator) Value() BackendAddressPool {
+ if !iter.page.NotDone() {
+ return BackendAddressPool{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the LoadBalancerBackendAddressPoolListResultIterator type.
+func NewLoadBalancerBackendAddressPoolListResultIterator(page LoadBalancerBackendAddressPoolListResultPage) LoadBalancerBackendAddressPoolListResultIterator {
+ return LoadBalancerBackendAddressPoolListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (lbbaplr LoadBalancerBackendAddressPoolListResult) IsEmpty() bool {
+ return lbbaplr.Value == nil || len(*lbbaplr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (lbbaplr LoadBalancerBackendAddressPoolListResult) hasNextLink() bool {
+ return lbbaplr.NextLink != nil && len(*lbbaplr.NextLink) != 0
+}
+
+// loadBalancerBackendAddressPoolListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (lbbaplr LoadBalancerBackendAddressPoolListResult) loadBalancerBackendAddressPoolListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !lbbaplr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(lbbaplr.NextLink)))
+}
+
+// LoadBalancerBackendAddressPoolListResultPage contains a page of BackendAddressPool values.
+type LoadBalancerBackendAddressPoolListResultPage struct {
+ fn func(context.Context, LoadBalancerBackendAddressPoolListResult) (LoadBalancerBackendAddressPoolListResult, error)
+ lbbaplr LoadBalancerBackendAddressPoolListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *LoadBalancerBackendAddressPoolListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerBackendAddressPoolListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.lbbaplr)
+ if err != nil {
+ return err
+ }
+ page.lbbaplr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *LoadBalancerBackendAddressPoolListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page LoadBalancerBackendAddressPoolListResultPage) NotDone() bool {
+ return !page.lbbaplr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page LoadBalancerBackendAddressPoolListResultPage) Response() LoadBalancerBackendAddressPoolListResult {
+ return page.lbbaplr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page LoadBalancerBackendAddressPoolListResultPage) Values() []BackendAddressPool {
+ if page.lbbaplr.IsEmpty() {
+ return nil
+ }
+ return *page.lbbaplr.Value
+}
+
+// Creates a new instance of the LoadBalancerBackendAddressPoolListResultPage type.
+func NewLoadBalancerBackendAddressPoolListResultPage(cur LoadBalancerBackendAddressPoolListResult, getNextPage func(context.Context, LoadBalancerBackendAddressPoolListResult) (LoadBalancerBackendAddressPoolListResult, error)) LoadBalancerBackendAddressPoolListResultPage {
+ return LoadBalancerBackendAddressPoolListResultPage{
+ fn: getNextPage,
+ lbbaplr: cur,
+ }
+}
+
+// LoadBalancerFrontendIPConfigurationListResult response for ListFrontendIPConfiguration API service call.
+type LoadBalancerFrontendIPConfigurationListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of frontend IP configurations in a load balancer.
+ Value *[]FrontendIPConfiguration `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LoadBalancerFrontendIPConfigurationListResult.
+func (lbficlr LoadBalancerFrontendIPConfigurationListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lbficlr.Value != nil {
+ objectMap["value"] = lbficlr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// LoadBalancerFrontendIPConfigurationListResultIterator provides access to a complete listing of
+// FrontendIPConfiguration values.
+type LoadBalancerFrontendIPConfigurationListResultIterator struct {
+ i int
+ page LoadBalancerFrontendIPConfigurationListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *LoadBalancerFrontendIPConfigurationListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerFrontendIPConfigurationListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *LoadBalancerFrontendIPConfigurationListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter LoadBalancerFrontendIPConfigurationListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter LoadBalancerFrontendIPConfigurationListResultIterator) Response() LoadBalancerFrontendIPConfigurationListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter LoadBalancerFrontendIPConfigurationListResultIterator) Value() FrontendIPConfiguration {
+ if !iter.page.NotDone() {
+ return FrontendIPConfiguration{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the LoadBalancerFrontendIPConfigurationListResultIterator type.
+func NewLoadBalancerFrontendIPConfigurationListResultIterator(page LoadBalancerFrontendIPConfigurationListResultPage) LoadBalancerFrontendIPConfigurationListResultIterator {
+ return LoadBalancerFrontendIPConfigurationListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (lbficlr LoadBalancerFrontendIPConfigurationListResult) IsEmpty() bool {
+ return lbficlr.Value == nil || len(*lbficlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (lbficlr LoadBalancerFrontendIPConfigurationListResult) hasNextLink() bool {
+ return lbficlr.NextLink != nil && len(*lbficlr.NextLink) != 0
+}
+
+// loadBalancerFrontendIPConfigurationListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (lbficlr LoadBalancerFrontendIPConfigurationListResult) loadBalancerFrontendIPConfigurationListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !lbficlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(lbficlr.NextLink)))
+}
+
+// LoadBalancerFrontendIPConfigurationListResultPage contains a page of FrontendIPConfiguration values.
+type LoadBalancerFrontendIPConfigurationListResultPage struct {
+ fn func(context.Context, LoadBalancerFrontendIPConfigurationListResult) (LoadBalancerFrontendIPConfigurationListResult, error)
+ lbficlr LoadBalancerFrontendIPConfigurationListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *LoadBalancerFrontendIPConfigurationListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerFrontendIPConfigurationListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.lbficlr)
+ if err != nil {
+ return err
+ }
+ page.lbficlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *LoadBalancerFrontendIPConfigurationListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page LoadBalancerFrontendIPConfigurationListResultPage) NotDone() bool {
+ return !page.lbficlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page LoadBalancerFrontendIPConfigurationListResultPage) Response() LoadBalancerFrontendIPConfigurationListResult {
+ return page.lbficlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page LoadBalancerFrontendIPConfigurationListResultPage) Values() []FrontendIPConfiguration {
+ if page.lbficlr.IsEmpty() {
+ return nil
+ }
+ return *page.lbficlr.Value
+}
+
+// Creates a new instance of the LoadBalancerFrontendIPConfigurationListResultPage type.
+func NewLoadBalancerFrontendIPConfigurationListResultPage(cur LoadBalancerFrontendIPConfigurationListResult, getNextPage func(context.Context, LoadBalancerFrontendIPConfigurationListResult) (LoadBalancerFrontendIPConfigurationListResult, error)) LoadBalancerFrontendIPConfigurationListResultPage {
+ return LoadBalancerFrontendIPConfigurationListResultPage{
+ fn: getNextPage,
+ lbficlr: cur,
+ }
+}
+
+// LoadBalancerListResult response for ListLoadBalancers API service call.
+type LoadBalancerListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of load balancers in a resource group.
+ Value *[]LoadBalancer `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LoadBalancerListResult.
+func (lblr LoadBalancerListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lblr.Value != nil {
+ objectMap["value"] = lblr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// LoadBalancerListResultIterator provides access to a complete listing of LoadBalancer values.
+type LoadBalancerListResultIterator struct {
+ i int
+ page LoadBalancerListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *LoadBalancerListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *LoadBalancerListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter LoadBalancerListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter LoadBalancerListResultIterator) Response() LoadBalancerListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter LoadBalancerListResultIterator) Value() LoadBalancer {
+ if !iter.page.NotDone() {
+ return LoadBalancer{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the LoadBalancerListResultIterator type.
+func NewLoadBalancerListResultIterator(page LoadBalancerListResultPage) LoadBalancerListResultIterator {
+ return LoadBalancerListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (lblr LoadBalancerListResult) IsEmpty() bool {
+ return lblr.Value == nil || len(*lblr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (lblr LoadBalancerListResult) hasNextLink() bool {
+ return lblr.NextLink != nil && len(*lblr.NextLink) != 0
+}
+
+// loadBalancerListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (lblr LoadBalancerListResult) loadBalancerListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !lblr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(lblr.NextLink)))
+}
+
+// LoadBalancerListResultPage contains a page of LoadBalancer values.
+type LoadBalancerListResultPage struct {
+ fn func(context.Context, LoadBalancerListResult) (LoadBalancerListResult, error)
+ lblr LoadBalancerListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *LoadBalancerListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.lblr)
+ if err != nil {
+ return err
+ }
+ page.lblr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *LoadBalancerListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page LoadBalancerListResultPage) NotDone() bool {
+ return !page.lblr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page LoadBalancerListResultPage) Response() LoadBalancerListResult {
+ return page.lblr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page LoadBalancerListResultPage) Values() []LoadBalancer {
+ if page.lblr.IsEmpty() {
+ return nil
+ }
+ return *page.lblr.Value
+}
+
+// Creates a new instance of the LoadBalancerListResultPage type.
+func NewLoadBalancerListResultPage(cur LoadBalancerListResult, getNextPage func(context.Context, LoadBalancerListResult) (LoadBalancerListResult, error)) LoadBalancerListResultPage {
+ return LoadBalancerListResultPage{
+ fn: getNextPage,
+ lblr: cur,
+ }
+}
+
+// LoadBalancerLoadBalancingRuleListResult response for ListLoadBalancingRule API service call.
+type LoadBalancerLoadBalancingRuleListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of load balancing rules in a load balancer.
+ Value *[]LoadBalancingRule `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LoadBalancerLoadBalancingRuleListResult.
+func (lblbrlr LoadBalancerLoadBalancingRuleListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lblbrlr.Value != nil {
+ objectMap["value"] = lblbrlr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// LoadBalancerLoadBalancingRuleListResultIterator provides access to a complete listing of
+// LoadBalancingRule values.
+type LoadBalancerLoadBalancingRuleListResultIterator struct {
+ i int
+ page LoadBalancerLoadBalancingRuleListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *LoadBalancerLoadBalancingRuleListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerLoadBalancingRuleListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *LoadBalancerLoadBalancingRuleListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter LoadBalancerLoadBalancingRuleListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter LoadBalancerLoadBalancingRuleListResultIterator) Response() LoadBalancerLoadBalancingRuleListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter LoadBalancerLoadBalancingRuleListResultIterator) Value() LoadBalancingRule {
+ if !iter.page.NotDone() {
+ return LoadBalancingRule{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the LoadBalancerLoadBalancingRuleListResultIterator type.
+func NewLoadBalancerLoadBalancingRuleListResultIterator(page LoadBalancerLoadBalancingRuleListResultPage) LoadBalancerLoadBalancingRuleListResultIterator {
+ return LoadBalancerLoadBalancingRuleListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (lblbrlr LoadBalancerLoadBalancingRuleListResult) IsEmpty() bool {
+ return lblbrlr.Value == nil || len(*lblbrlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (lblbrlr LoadBalancerLoadBalancingRuleListResult) hasNextLink() bool {
+ return lblbrlr.NextLink != nil && len(*lblbrlr.NextLink) != 0
+}
+
+// loadBalancerLoadBalancingRuleListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (lblbrlr LoadBalancerLoadBalancingRuleListResult) loadBalancerLoadBalancingRuleListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !lblbrlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(lblbrlr.NextLink)))
+}
+
+// LoadBalancerLoadBalancingRuleListResultPage contains a page of LoadBalancingRule values.
+type LoadBalancerLoadBalancingRuleListResultPage struct {
+ fn func(context.Context, LoadBalancerLoadBalancingRuleListResult) (LoadBalancerLoadBalancingRuleListResult, error)
+ lblbrlr LoadBalancerLoadBalancingRuleListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *LoadBalancerLoadBalancingRuleListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerLoadBalancingRuleListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.lblbrlr)
+ if err != nil {
+ return err
+ }
+ page.lblbrlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *LoadBalancerLoadBalancingRuleListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page LoadBalancerLoadBalancingRuleListResultPage) NotDone() bool {
+ return !page.lblbrlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page LoadBalancerLoadBalancingRuleListResultPage) Response() LoadBalancerLoadBalancingRuleListResult {
+ return page.lblbrlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page LoadBalancerLoadBalancingRuleListResultPage) Values() []LoadBalancingRule {
+ if page.lblbrlr.IsEmpty() {
+ return nil
+ }
+ return *page.lblbrlr.Value
+}
+
+// Creates a new instance of the LoadBalancerLoadBalancingRuleListResultPage type.
+func NewLoadBalancerLoadBalancingRuleListResultPage(cur LoadBalancerLoadBalancingRuleListResult, getNextPage func(context.Context, LoadBalancerLoadBalancingRuleListResult) (LoadBalancerLoadBalancingRuleListResult, error)) LoadBalancerLoadBalancingRuleListResultPage {
+ return LoadBalancerLoadBalancingRuleListResultPage{
+ fn: getNextPage,
+ lblbrlr: cur,
+ }
+}
+
+// LoadBalancerProbeListResult response for ListProbe API service call.
+type LoadBalancerProbeListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of probes in a load balancer.
+ Value *[]Probe `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LoadBalancerProbeListResult.
+func (lbplr LoadBalancerProbeListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lbplr.Value != nil {
+ objectMap["value"] = lbplr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// LoadBalancerProbeListResultIterator provides access to a complete listing of Probe values.
+type LoadBalancerProbeListResultIterator struct {
+ i int
+ page LoadBalancerProbeListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *LoadBalancerProbeListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbeListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *LoadBalancerProbeListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter LoadBalancerProbeListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter LoadBalancerProbeListResultIterator) Response() LoadBalancerProbeListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter LoadBalancerProbeListResultIterator) Value() Probe {
+ if !iter.page.NotDone() {
+ return Probe{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the LoadBalancerProbeListResultIterator type.
+func NewLoadBalancerProbeListResultIterator(page LoadBalancerProbeListResultPage) LoadBalancerProbeListResultIterator {
+ return LoadBalancerProbeListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (lbplr LoadBalancerProbeListResult) IsEmpty() bool {
+ return lbplr.Value == nil || len(*lbplr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (lbplr LoadBalancerProbeListResult) hasNextLink() bool {
+ return lbplr.NextLink != nil && len(*lbplr.NextLink) != 0
+}
+
+// loadBalancerProbeListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (lbplr LoadBalancerProbeListResult) loadBalancerProbeListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !lbplr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(lbplr.NextLink)))
+}
+
+// LoadBalancerProbeListResultPage contains a page of Probe values.
+type LoadBalancerProbeListResultPage struct {
+ fn func(context.Context, LoadBalancerProbeListResult) (LoadBalancerProbeListResult, error)
+ lbplr LoadBalancerProbeListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *LoadBalancerProbeListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbeListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.lbplr)
+ if err != nil {
+ return err
+ }
+ page.lbplr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *LoadBalancerProbeListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page LoadBalancerProbeListResultPage) NotDone() bool {
+ return !page.lbplr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page LoadBalancerProbeListResultPage) Response() LoadBalancerProbeListResult {
+ return page.lbplr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page LoadBalancerProbeListResultPage) Values() []Probe {
+ if page.lbplr.IsEmpty() {
+ return nil
+ }
+ return *page.lbplr.Value
+}
+
+// Creates a new instance of the LoadBalancerProbeListResultPage type.
+func NewLoadBalancerProbeListResultPage(cur LoadBalancerProbeListResult, getNextPage func(context.Context, LoadBalancerProbeListResult) (LoadBalancerProbeListResult, error)) LoadBalancerProbeListResultPage {
+ return LoadBalancerProbeListResultPage{
+ fn: getNextPage,
+ lbplr: cur,
+ }
+}
+
+// LoadBalancerPropertiesFormat properties of the load balancer.
+type LoadBalancerPropertiesFormat struct {
+ // FrontendIPConfigurations - Object representing the frontend IPs to be used for the load balancer
+ FrontendIPConfigurations *[]FrontendIPConfiguration `json:"frontendIPConfigurations,omitempty"`
+ // BackendAddressPools - Collection of backend address pools used by a load balancer
+ BackendAddressPools *[]BackendAddressPool `json:"backendAddressPools,omitempty"`
+ // LoadBalancingRules - Object collection representing the load balancing rules Gets the provisioning
+ LoadBalancingRules *[]LoadBalancingRule `json:"loadBalancingRules,omitempty"`
+ // Probes - Collection of probe objects used in the load balancer
+ Probes *[]Probe `json:"probes,omitempty"`
+ // InboundNatRules - Collection of inbound NAT Rules used by a load balancer. Defining inbound NAT rules on your load balancer is mutually exclusive with defining an inbound NAT pool. Inbound NAT pools are referenced from virtual machine scale sets. NICs that are associated with individual virtual machines cannot reference an Inbound NAT pool. They have to reference individual inbound NAT rules.
+ InboundNatRules *[]InboundNatRule `json:"inboundNatRules,omitempty"`
+ // InboundNatPools - Defines an external port range for inbound NAT to a single backend port on NICs associated with a load balancer. Inbound NAT rules are created automatically for each NIC associated with the Load Balancer using an external port from this range. Defining an Inbound NAT pool on your Load Balancer is mutually exclusive with defining inbound Nat rules. Inbound NAT pools are referenced from virtual machine scale sets. NICs that are associated with individual virtual machines cannot reference an inbound NAT pool. They have to reference individual inbound NAT rules.
+ InboundNatPools *[]InboundNatPool `json:"inboundNatPools,omitempty"`
+ // OutboundNatRules - The outbound NAT rules.
+ OutboundNatRules *[]OutboundNatRule `json:"outboundNatRules,omitempty"`
+ // ResourceGUID - The resource GUID property of the load balancer resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// LoadBalancersCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type LoadBalancersCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LoadBalancersClient) (LoadBalancer, error)
+}
+
+// LoadBalancersDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type LoadBalancersDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LoadBalancersClient) (autorest.Response, error)
+}
+
+// LoadBalancerSku SKU of a load balancer
+type LoadBalancerSku struct {
+ // Name - Name of a load balancer SKU. Possible values include: 'LoadBalancerSkuNameBasic', 'LoadBalancerSkuNameStandard'
+ Name LoadBalancerSkuName `json:"name,omitempty"`
+}
+
+// LoadBalancersUpdateTagsFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type LoadBalancersUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LoadBalancersClient) (LoadBalancer, error)
+}
+
+// LoadBalancingRule a load balancing rule for a load balancer.
+type LoadBalancingRule struct {
+ autorest.Response `json:"-"`
+ // LoadBalancingRulePropertiesFormat - Properties of load balancer load balancing rule.
+ *LoadBalancingRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LoadBalancingRule.
+func (lbr LoadBalancingRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lbr.LoadBalancingRulePropertiesFormat != nil {
+ objectMap["properties"] = lbr.LoadBalancingRulePropertiesFormat
+ }
+ if lbr.Name != nil {
+ objectMap["name"] = lbr.Name
+ }
+ if lbr.Etag != nil {
+ objectMap["etag"] = lbr.Etag
+ }
+ if lbr.ID != nil {
+ objectMap["id"] = lbr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for LoadBalancingRule struct.
+func (lbr *LoadBalancingRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var loadBalancingRulePropertiesFormat LoadBalancingRulePropertiesFormat
+ err = json.Unmarshal(*v, &loadBalancingRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ lbr.LoadBalancingRulePropertiesFormat = &loadBalancingRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ lbr.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ lbr.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ lbr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// LoadBalancingRulePropertiesFormat properties of the load balancer.
+type LoadBalancingRulePropertiesFormat struct {
+ // FrontendIPConfiguration - A reference to frontend IP addresses.
+ FrontendIPConfiguration *SubResource `json:"frontendIPConfiguration,omitempty"`
+ // BackendAddressPool - A reference to a pool of DIPs. Inbound traffic is randomly load balanced across IPs in the backend IPs.
+ BackendAddressPool *SubResource `json:"backendAddressPool,omitempty"`
+ // Probe - The reference of the load balancer probe used by the load balancing rule.
+ Probe *SubResource `json:"probe,omitempty"`
+ // Protocol - Possible values include: 'TransportProtocolUDP', 'TransportProtocolTCP', 'TransportProtocolAll'
+ Protocol TransportProtocol `json:"protocol,omitempty"`
+ // LoadDistribution - The load distribution policy for this rule. Possible values are 'Default', 'SourceIP', and 'SourceIPProtocol'. Possible values include: 'Default', 'SourceIP', 'SourceIPProtocol'
+ LoadDistribution LoadDistribution `json:"loadDistribution,omitempty"`
+ // FrontendPort - The port for the external endpoint. Port numbers for each rule must be unique within the Load Balancer. Acceptable values are between 0 and 65534. Note that value 0 enables "Any Port"
+ FrontendPort *int32 `json:"frontendPort,omitempty"`
+ // BackendPort - The port used for internal connections on the endpoint. Acceptable values are between 0 and 65535. Note that value 0 enables "Any Port"
+ BackendPort *int32 `json:"backendPort,omitempty"`
+ // IdleTimeoutInMinutes - The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
+ IdleTimeoutInMinutes *int32 `json:"idleTimeoutInMinutes,omitempty"`
+ // EnableFloatingIP - Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
+ EnableFloatingIP *bool `json:"enableFloatingIP,omitempty"`
+ // DisableOutboundSnat - Configures SNAT for the VMs in the backend pool to use the publicIP address specified in the frontend of the load balancing rule.
+ DisableOutboundSnat *bool `json:"disableOutboundSnat,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// LocalNetworkGateway a common class for general resource information
+type LocalNetworkGateway struct {
+ autorest.Response `json:"-"`
+ // LocalNetworkGatewayPropertiesFormat - Properties of the local network gateway.
+ *LocalNetworkGatewayPropertiesFormat `json:"properties,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for LocalNetworkGateway.
+func (lng LocalNetworkGateway) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lng.LocalNetworkGatewayPropertiesFormat != nil {
+ objectMap["properties"] = lng.LocalNetworkGatewayPropertiesFormat
+ }
+ if lng.Etag != nil {
+ objectMap["etag"] = lng.Etag
+ }
+ if lng.ID != nil {
+ objectMap["id"] = lng.ID
+ }
+ if lng.Location != nil {
+ objectMap["location"] = lng.Location
+ }
+ if lng.Tags != nil {
+ objectMap["tags"] = lng.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for LocalNetworkGateway struct.
+func (lng *LocalNetworkGateway) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var localNetworkGatewayPropertiesFormat LocalNetworkGatewayPropertiesFormat
+ err = json.Unmarshal(*v, &localNetworkGatewayPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ lng.LocalNetworkGatewayPropertiesFormat = &localNetworkGatewayPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ lng.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ lng.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ lng.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ lng.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ lng.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ lng.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// LocalNetworkGatewayListResult response for ListLocalNetworkGateways API service call.
+type LocalNetworkGatewayListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of local network gateways that exists in a resource group.
+ Value *[]LocalNetworkGateway `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LocalNetworkGatewayListResult.
+func (lnglr LocalNetworkGatewayListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lnglr.Value != nil {
+ objectMap["value"] = lnglr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// LocalNetworkGatewayListResultIterator provides access to a complete listing of LocalNetworkGateway
+// values.
+type LocalNetworkGatewayListResultIterator struct {
+ i int
+ page LocalNetworkGatewayListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *LocalNetworkGatewayListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewayListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *LocalNetworkGatewayListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter LocalNetworkGatewayListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter LocalNetworkGatewayListResultIterator) Response() LocalNetworkGatewayListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter LocalNetworkGatewayListResultIterator) Value() LocalNetworkGateway {
+ if !iter.page.NotDone() {
+ return LocalNetworkGateway{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the LocalNetworkGatewayListResultIterator type.
+func NewLocalNetworkGatewayListResultIterator(page LocalNetworkGatewayListResultPage) LocalNetworkGatewayListResultIterator {
+ return LocalNetworkGatewayListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (lnglr LocalNetworkGatewayListResult) IsEmpty() bool {
+ return lnglr.Value == nil || len(*lnglr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (lnglr LocalNetworkGatewayListResult) hasNextLink() bool {
+ return lnglr.NextLink != nil && len(*lnglr.NextLink) != 0
+}
+
+// localNetworkGatewayListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (lnglr LocalNetworkGatewayListResult) localNetworkGatewayListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !lnglr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(lnglr.NextLink)))
+}
+
+// LocalNetworkGatewayListResultPage contains a page of LocalNetworkGateway values.
+type LocalNetworkGatewayListResultPage struct {
+ fn func(context.Context, LocalNetworkGatewayListResult) (LocalNetworkGatewayListResult, error)
+ lnglr LocalNetworkGatewayListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *LocalNetworkGatewayListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/LocalNetworkGatewayListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.lnglr)
+ if err != nil {
+ return err
+ }
+ page.lnglr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *LocalNetworkGatewayListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page LocalNetworkGatewayListResultPage) NotDone() bool {
+ return !page.lnglr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page LocalNetworkGatewayListResultPage) Response() LocalNetworkGatewayListResult {
+ return page.lnglr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page LocalNetworkGatewayListResultPage) Values() []LocalNetworkGateway {
+ if page.lnglr.IsEmpty() {
+ return nil
+ }
+ return *page.lnglr.Value
+}
+
+// Creates a new instance of the LocalNetworkGatewayListResultPage type.
+func NewLocalNetworkGatewayListResultPage(cur LocalNetworkGatewayListResult, getNextPage func(context.Context, LocalNetworkGatewayListResult) (LocalNetworkGatewayListResult, error)) LocalNetworkGatewayListResultPage {
+ return LocalNetworkGatewayListResultPage{
+ fn: getNextPage,
+ lnglr: cur,
+ }
+}
+
+// LocalNetworkGatewayPropertiesFormat localNetworkGateway properties
+type LocalNetworkGatewayPropertiesFormat struct {
+ // LocalNetworkAddressSpace - Local network site address space.
+ LocalNetworkAddressSpace *AddressSpace `json:"localNetworkAddressSpace,omitempty"`
+ // GatewayIPAddress - IP address of local network gateway.
+ GatewayIPAddress *string `json:"gatewayIpAddress,omitempty"`
+ // BgpSettings - Local network gateway's BGP speaker settings.
+ BgpSettings *BgpSettings `json:"bgpSettings,omitempty"`
+ // ResourceGUID - The resource GUID property of the LocalNetworkGateway resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the LocalNetworkGateway resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for LocalNetworkGatewayPropertiesFormat.
+func (lngpf LocalNetworkGatewayPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if lngpf.LocalNetworkAddressSpace != nil {
+ objectMap["localNetworkAddressSpace"] = lngpf.LocalNetworkAddressSpace
+ }
+ if lngpf.GatewayIPAddress != nil {
+ objectMap["gatewayIpAddress"] = lngpf.GatewayIPAddress
+ }
+ if lngpf.BgpSettings != nil {
+ objectMap["bgpSettings"] = lngpf.BgpSettings
+ }
+ if lngpf.ResourceGUID != nil {
+ objectMap["resourceGuid"] = lngpf.ResourceGUID
+ }
+ return json.Marshal(objectMap)
+}
+
+// LocalNetworkGatewaysCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type LocalNetworkGatewaysCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LocalNetworkGatewaysClient) (LocalNetworkGateway, error)
+}
+
+// LocalNetworkGatewaysDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type LocalNetworkGatewaysDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LocalNetworkGatewaysClient) (autorest.Response, error)
+}
+
+// LocalNetworkGatewaysUpdateTagsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type LocalNetworkGatewaysUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(LocalNetworkGatewaysClient) (LocalNetworkGateway, error)
+}
+
+// LogSpecification description of logging specification.
+type LogSpecification struct {
+ // Name - The name of the specification.
+ Name *string `json:"name,omitempty"`
+ // DisplayName - The display name of the specification.
+ DisplayName *string `json:"displayName,omitempty"`
+ // BlobDuration - Duration of the blob.
+ BlobDuration *string `json:"blobDuration,omitempty"`
+}
+
+// MetricSpecification description of metrics specification.
+type MetricSpecification struct {
+ // Name - The name of the metric.
+ Name *string `json:"name,omitempty"`
+ // DisplayName - The display name of the metric.
+ DisplayName *string `json:"displayName,omitempty"`
+ // DisplayDescription - The description of the metric.
+ DisplayDescription *string `json:"displayDescription,omitempty"`
+ // Unit - Units the metric to be displayed in.
+ Unit *string `json:"unit,omitempty"`
+ // AggregationType - The aggregation type.
+ AggregationType *string `json:"aggregationType,omitempty"`
+ // Availabilities - List of availability.
+ Availabilities *[]Availability `json:"availabilities,omitempty"`
+ // EnableRegionalMdmAccount - Whether regional MDM account enabled.
+ EnableRegionalMdmAccount *bool `json:"enableRegionalMdmAccount,omitempty"`
+ // FillGapWithZero - Whether gaps would be filled with zeros.
+ FillGapWithZero *bool `json:"fillGapWithZero,omitempty"`
+ // MetricFilterPattern - Pattern for the filter of the metric.
+ MetricFilterPattern *string `json:"metricFilterPattern,omitempty"`
+ // Dimensions - List of dimensions.
+ Dimensions *[]Dimension `json:"dimensions,omitempty"`
+ // IsInternal - Whether the metric is internal.
+ IsInternal *bool `json:"isInternal,omitempty"`
+ // SourceMdmAccount - The source MDM account.
+ SourceMdmAccount *string `json:"sourceMdmAccount,omitempty"`
+ // SourceMdmNamespace - The source MDM namespace.
+ SourceMdmNamespace *string `json:"sourceMdmNamespace,omitempty"`
+ // ResourceIDDimensionNameOverride - The resource Id dimension name override.
+ ResourceIDDimensionNameOverride *string `json:"resourceIdDimensionNameOverride,omitempty"`
+}
+
+// NextHopParameters parameters that define the source and destination endpoint.
+type NextHopParameters struct {
+ // TargetResourceID - The resource identifier of the target resource against which the action is to be performed.
+ TargetResourceID *string `json:"targetResourceId,omitempty"`
+ // SourceIPAddress - The source IP address.
+ SourceIPAddress *string `json:"sourceIPAddress,omitempty"`
+ // DestinationIPAddress - The destination IP address.
+ DestinationIPAddress *string `json:"destinationIPAddress,omitempty"`
+ // TargetNicResourceID - The NIC ID. (If VM has multiple NICs and IP forwarding is enabled on any of the nics, then this parameter must be specified. Otherwise optional).
+ TargetNicResourceID *string `json:"targetNicResourceId,omitempty"`
+}
+
+// NextHopResult the information about next hop from the specified VM.
+type NextHopResult struct {
+ autorest.Response `json:"-"`
+ // NextHopType - Next hop type. Possible values include: 'NextHopTypeInternet', 'NextHopTypeVirtualAppliance', 'NextHopTypeVirtualNetworkGateway', 'NextHopTypeVnetLocal', 'NextHopTypeHyperNetGateway', 'NextHopTypeNone'
+ NextHopType NextHopType `json:"nextHopType,omitempty"`
+ // NextHopIPAddress - Next hop IP Address
+ NextHopIPAddress *string `json:"nextHopIpAddress,omitempty"`
+ // RouteTableID - The resource identifier for the route table associated with the route being returned. If the route being returned does not correspond to any user created routes then this field will be the string 'System Route'.
+ RouteTableID *string `json:"routeTableId,omitempty"`
+}
+
+// Operation network REST API operation definition.
+type Operation struct {
+ // Name - Operation name: {provider}/{resource}/{operation}
+ Name *string `json:"name,omitempty"`
+ // Display - Display metadata associated with the operation.
+ Display *OperationDisplay `json:"display,omitempty"`
+ // Origin - Origin of the operation.
+ Origin *string `json:"origin,omitempty"`
+ // OperationPropertiesFormat - Operation properties format.
+ *OperationPropertiesFormat `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Operation.
+func (o Operation) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if o.Name != nil {
+ objectMap["name"] = o.Name
+ }
+ if o.Display != nil {
+ objectMap["display"] = o.Display
+ }
+ if o.Origin != nil {
+ objectMap["origin"] = o.Origin
+ }
+ if o.OperationPropertiesFormat != nil {
+ objectMap["properties"] = o.OperationPropertiesFormat
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Operation struct.
+func (o *Operation) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ o.Name = &name
+ }
+ case "display":
+ if v != nil {
+ var display OperationDisplay
+ err = json.Unmarshal(*v, &display)
+ if err != nil {
+ return err
+ }
+ o.Display = &display
+ }
+ case "origin":
+ if v != nil {
+ var origin string
+ err = json.Unmarshal(*v, &origin)
+ if err != nil {
+ return err
+ }
+ o.Origin = &origin
+ }
+ case "properties":
+ if v != nil {
+ var operationPropertiesFormat OperationPropertiesFormat
+ err = json.Unmarshal(*v, &operationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ o.OperationPropertiesFormat = &operationPropertiesFormat
+ }
+ }
+ }
+
+ return nil
+}
+
+// OperationDisplay display metadata associated with the operation.
+type OperationDisplay struct {
+ // Provider - Service provider: Microsoft Network.
+ Provider *string `json:"provider,omitempty"`
+ // Resource - Resource on which the operation is performed.
+ Resource *string `json:"resource,omitempty"`
+ // Operation - Type of the operation: get, read, delete, etc.
+ Operation *string `json:"operation,omitempty"`
+ // Description - Description of the operation.
+ Description *string `json:"description,omitempty"`
+}
+
+// OperationListResult result of the request to list Network operations. It contains a list of operations
+// and a URL link to get the next set of results.
+type OperationListResult struct {
+ autorest.Response `json:"-"`
+ // Value - List of Network operations supported by the Network resource provider.
+ Value *[]Operation `json:"value,omitempty"`
+ // NextLink - URL to get the next set of operation list results if there are any.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// OperationListResultIterator provides access to a complete listing of Operation values.
+type OperationListResultIterator struct {
+ i int
+ page OperationListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *OperationListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/OperationListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *OperationListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter OperationListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter OperationListResultIterator) Response() OperationListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter OperationListResultIterator) Value() Operation {
+ if !iter.page.NotDone() {
+ return Operation{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the OperationListResultIterator type.
+func NewOperationListResultIterator(page OperationListResultPage) OperationListResultIterator {
+ return OperationListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (olr OperationListResult) IsEmpty() bool {
+ return olr.Value == nil || len(*olr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (olr OperationListResult) hasNextLink() bool {
+ return olr.NextLink != nil && len(*olr.NextLink) != 0
+}
+
+// operationListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (olr OperationListResult) operationListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !olr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(olr.NextLink)))
+}
+
+// OperationListResultPage contains a page of Operation values.
+type OperationListResultPage struct {
+ fn func(context.Context, OperationListResult) (OperationListResult, error)
+ olr OperationListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *OperationListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/OperationListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.olr)
+ if err != nil {
+ return err
+ }
+ page.olr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *OperationListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page OperationListResultPage) NotDone() bool {
+ return !page.olr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page OperationListResultPage) Response() OperationListResult {
+ return page.olr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page OperationListResultPage) Values() []Operation {
+ if page.olr.IsEmpty() {
+ return nil
+ }
+ return *page.olr.Value
+}
+
+// Creates a new instance of the OperationListResultPage type.
+func NewOperationListResultPage(cur OperationListResult, getNextPage func(context.Context, OperationListResult) (OperationListResult, error)) OperationListResultPage {
+ return OperationListResultPage{
+ fn: getNextPage,
+ olr: cur,
+ }
+}
+
+// OperationPropertiesFormat description of operation properties format.
+type OperationPropertiesFormat struct {
+ // ServiceSpecification - Specification of the service.
+ ServiceSpecification *OperationPropertiesFormatServiceSpecification `json:"serviceSpecification,omitempty"`
+}
+
+// OperationPropertiesFormatServiceSpecification specification of the service.
+type OperationPropertiesFormatServiceSpecification struct {
+ // MetricSpecifications - Operation service specification.
+ MetricSpecifications *[]MetricSpecification `json:"metricSpecifications,omitempty"`
+ // LogSpecifications - Operation log specification.
+ LogSpecifications *[]LogSpecification `json:"logSpecifications,omitempty"`
+}
+
+// OutboundNatRule outbound NAT pool of the load balancer.
+type OutboundNatRule struct {
+ // OutboundNatRulePropertiesFormat - Properties of load balancer outbound nat rule.
+ *OutboundNatRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for OutboundNatRule.
+func (onr OutboundNatRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if onr.OutboundNatRulePropertiesFormat != nil {
+ objectMap["properties"] = onr.OutboundNatRulePropertiesFormat
+ }
+ if onr.Name != nil {
+ objectMap["name"] = onr.Name
+ }
+ if onr.Etag != nil {
+ objectMap["etag"] = onr.Etag
+ }
+ if onr.ID != nil {
+ objectMap["id"] = onr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for OutboundNatRule struct.
+func (onr *OutboundNatRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var outboundNatRulePropertiesFormat OutboundNatRulePropertiesFormat
+ err = json.Unmarshal(*v, &outboundNatRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ onr.OutboundNatRulePropertiesFormat = &outboundNatRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ onr.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ onr.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ onr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// OutboundNatRulePropertiesFormat outbound NAT pool of the load balancer.
+type OutboundNatRulePropertiesFormat struct {
+ // AllocatedOutboundPorts - The number of outbound ports to be used for NAT.
+ AllocatedOutboundPorts *int32 `json:"allocatedOutboundPorts,omitempty"`
+ // FrontendIPConfigurations - The Frontend IP addresses of the load balancer.
+ FrontendIPConfigurations *[]SubResource `json:"frontendIPConfigurations,omitempty"`
+ // BackendAddressPool - A reference to a pool of DIPs. Outbound traffic is randomly load balanced across IPs in the backend IPs.
+ BackendAddressPool *SubResource `json:"backendAddressPool,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// PacketCapture parameters that define the create packet capture operation.
+type PacketCapture struct {
+ *PacketCaptureParameters `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for PacketCapture.
+func (pc PacketCapture) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if pc.PacketCaptureParameters != nil {
+ objectMap["properties"] = pc.PacketCaptureParameters
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for PacketCapture struct.
+func (pc *PacketCapture) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var packetCaptureParameters PacketCaptureParameters
+ err = json.Unmarshal(*v, &packetCaptureParameters)
+ if err != nil {
+ return err
+ }
+ pc.PacketCaptureParameters = &packetCaptureParameters
+ }
+ }
+ }
+
+ return nil
+}
+
+// PacketCaptureFilter filter that is applied to packet capture request. Multiple filters can be applied.
+type PacketCaptureFilter struct {
+ // Protocol - Protocol to be filtered on. Possible values include: 'PcProtocolTCP', 'PcProtocolUDP', 'PcProtocolAny'
+ Protocol PcProtocol `json:"protocol,omitempty"`
+ // LocalIPAddress - Local IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5"? for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Default = null.
+ LocalIPAddress *string `json:"localIPAddress,omitempty"`
+ // RemoteIPAddress - Local IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Default = null.
+ RemoteIPAddress *string `json:"remoteIPAddress,omitempty"`
+ // LocalPort - Local port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Default = null.
+ LocalPort *string `json:"localPort,omitempty"`
+ // RemotePort - Remote port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Default = null.
+ RemotePort *string `json:"remotePort,omitempty"`
+}
+
+// PacketCaptureListResult list of packet capture sessions.
+type PacketCaptureListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Information about packet capture sessions.
+ Value *[]PacketCaptureResult `json:"value,omitempty"`
+}
+
+// PacketCaptureParameters parameters that define the create packet capture operation.
+type PacketCaptureParameters struct {
+ // Target - The ID of the targeted resource, only VM is currently supported.
+ Target *string `json:"target,omitempty"`
+ // BytesToCapturePerPacket - Number of bytes captured per packet, the remaining bytes are truncated.
+ BytesToCapturePerPacket *int32 `json:"bytesToCapturePerPacket,omitempty"`
+ // TotalBytesPerSession - Maximum size of the capture output.
+ TotalBytesPerSession *int32 `json:"totalBytesPerSession,omitempty"`
+ // TimeLimitInSeconds - Maximum duration of the capture session in seconds.
+ TimeLimitInSeconds *int32 `json:"timeLimitInSeconds,omitempty"`
+ StorageLocation *PacketCaptureStorageLocation `json:"storageLocation,omitempty"`
+ Filters *[]PacketCaptureFilter `json:"filters,omitempty"`
+}
+
+// PacketCaptureQueryStatusResult status of packet capture session.
+type PacketCaptureQueryStatusResult struct {
+ autorest.Response `json:"-"`
+ // Name - The name of the packet capture resource.
+ Name *string `json:"name,omitempty"`
+ // ID - The ID of the packet capture resource.
+ ID *string `json:"id,omitempty"`
+ // CaptureStartTime - The start time of the packet capture session.
+ CaptureStartTime *date.Time `json:"captureStartTime,omitempty"`
+ // PacketCaptureStatus - The status of the packet capture session. Possible values include: 'PcStatusNotStarted', 'PcStatusRunning', 'PcStatusStopped', 'PcStatusError', 'PcStatusUnknown'
+ PacketCaptureStatus PcStatus `json:"packetCaptureStatus,omitempty"`
+ // StopReason - The reason the current packet capture session was stopped.
+ StopReason *string `json:"stopReason,omitempty"`
+ // PacketCaptureError - List of errors of packet capture session.
+ PacketCaptureError *[]PcError `json:"packetCaptureError,omitempty"`
+}
+
+// PacketCaptureResult information about packet capture session.
+type PacketCaptureResult struct {
+ autorest.Response `json:"-"`
+ // Name - READ-ONLY; Name of the packet capture session.
+ Name *string `json:"name,omitempty"`
+ // ID - READ-ONLY; ID of the packet capture operation.
+ ID *string `json:"id,omitempty"`
+ Etag *string `json:"etag,omitempty"`
+ *PacketCaptureResultProperties `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for PacketCaptureResult.
+func (pcr PacketCaptureResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if pcr.Etag != nil {
+ objectMap["etag"] = pcr.Etag
+ }
+ if pcr.PacketCaptureResultProperties != nil {
+ objectMap["properties"] = pcr.PacketCaptureResultProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for PacketCaptureResult struct.
+func (pcr *PacketCaptureResult) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ pcr.Name = &name
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ pcr.ID = &ID
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ pcr.Etag = &etag
+ }
+ case "properties":
+ if v != nil {
+ var packetCaptureResultProperties PacketCaptureResultProperties
+ err = json.Unmarshal(*v, &packetCaptureResultProperties)
+ if err != nil {
+ return err
+ }
+ pcr.PacketCaptureResultProperties = &packetCaptureResultProperties
+ }
+ }
+ }
+
+ return nil
+}
+
+// PacketCaptureResultProperties describes the properties of a packet capture session.
+type PacketCaptureResultProperties struct {
+ // ProvisioningState - The provisioning state of the packet capture session. Possible values include: 'Succeeded', 'Updating', 'Deleting', 'Failed'
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+ // Target - The ID of the targeted resource, only VM is currently supported.
+ Target *string `json:"target,omitempty"`
+ // BytesToCapturePerPacket - Number of bytes captured per packet, the remaining bytes are truncated.
+ BytesToCapturePerPacket *int32 `json:"bytesToCapturePerPacket,omitempty"`
+ // TotalBytesPerSession - Maximum size of the capture output.
+ TotalBytesPerSession *int32 `json:"totalBytesPerSession,omitempty"`
+ // TimeLimitInSeconds - Maximum duration of the capture session in seconds.
+ TimeLimitInSeconds *int32 `json:"timeLimitInSeconds,omitempty"`
+ StorageLocation *PacketCaptureStorageLocation `json:"storageLocation,omitempty"`
+ Filters *[]PacketCaptureFilter `json:"filters,omitempty"`
+}
+
+// PacketCapturesCreateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type PacketCapturesCreateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(PacketCapturesClient) (PacketCaptureResult, error)
+}
+
+// PacketCapturesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type PacketCapturesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(PacketCapturesClient) (autorest.Response, error)
+}
+
+// PacketCapturesGetStatusFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type PacketCapturesGetStatusFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(PacketCapturesClient) (PacketCaptureQueryStatusResult, error)
+}
+
+// PacketCapturesStopFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type PacketCapturesStopFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(PacketCapturesClient) (autorest.Response, error)
+}
+
+// PacketCaptureStorageLocation describes the storage location for a packet capture session.
+type PacketCaptureStorageLocation struct {
+ // StorageID - The ID of the storage account to save the packet capture session. Required if no local file path is provided.
+ StorageID *string `json:"storageId,omitempty"`
+ // StoragePath - The URI of the storage path to save the packet capture. Must be a well-formed URI describing the location to save the packet capture.
+ StoragePath *string `json:"storagePath,omitempty"`
+ // FilePath - A valid local path on the targeting VM. Must include the name of the capture file (*.cap). For linux virtual machine it must start with /var/captures. Required if no storage ID is provided, otherwise optional.
+ FilePath *string `json:"filePath,omitempty"`
+}
+
+// PatchRouteFilter route Filter Resource.
+type PatchRouteFilter struct {
+ *RouteFilterPropertiesFormat `json:"properties,omitempty"`
+ // Name - READ-ONLY; The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - READ-ONLY; A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for PatchRouteFilter.
+func (prf PatchRouteFilter) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if prf.RouteFilterPropertiesFormat != nil {
+ objectMap["properties"] = prf.RouteFilterPropertiesFormat
+ }
+ if prf.Tags != nil {
+ objectMap["tags"] = prf.Tags
+ }
+ if prf.ID != nil {
+ objectMap["id"] = prf.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for PatchRouteFilter struct.
+func (prf *PatchRouteFilter) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var routeFilterPropertiesFormat RouteFilterPropertiesFormat
+ err = json.Unmarshal(*v, &routeFilterPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ prf.RouteFilterPropertiesFormat = &routeFilterPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ prf.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ prf.Etag = &etag
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ prf.Type = &typeVar
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ prf.Tags = tags
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ prf.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// PatchRouteFilterRule route Filter Rule Resource
+type PatchRouteFilterRule struct {
+ *RouteFilterRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - READ-ONLY; The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - READ-ONLY; A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for PatchRouteFilterRule.
+func (prfr PatchRouteFilterRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if prfr.RouteFilterRulePropertiesFormat != nil {
+ objectMap["properties"] = prfr.RouteFilterRulePropertiesFormat
+ }
+ if prfr.Tags != nil {
+ objectMap["tags"] = prfr.Tags
+ }
+ if prfr.ID != nil {
+ objectMap["id"] = prfr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for PatchRouteFilterRule struct.
+func (prfr *PatchRouteFilterRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var routeFilterRulePropertiesFormat RouteFilterRulePropertiesFormat
+ err = json.Unmarshal(*v, &routeFilterRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ prfr.RouteFilterRulePropertiesFormat = &routeFilterRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ prfr.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ prfr.Etag = &etag
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ prfr.Tags = tags
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ prfr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// Probe a load balancer probe.
+type Probe struct {
+ autorest.Response `json:"-"`
+ // ProbePropertiesFormat - Properties of load balancer probe.
+ *ProbePropertiesFormat `json:"properties,omitempty"`
+ // Name - Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Probe.
+func (p Probe) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if p.ProbePropertiesFormat != nil {
+ objectMap["properties"] = p.ProbePropertiesFormat
+ }
+ if p.Name != nil {
+ objectMap["name"] = p.Name
+ }
+ if p.Etag != nil {
+ objectMap["etag"] = p.Etag
+ }
+ if p.ID != nil {
+ objectMap["id"] = p.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Probe struct.
+func (p *Probe) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var probePropertiesFormat ProbePropertiesFormat
+ err = json.Unmarshal(*v, &probePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ p.ProbePropertiesFormat = &probePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ p.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ p.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ p.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ProbePropertiesFormat load balancer probe resource.
+type ProbePropertiesFormat struct {
+ // LoadBalancingRules - READ-ONLY; The load balancer rules that use this probe.
+ LoadBalancingRules *[]SubResource `json:"loadBalancingRules,omitempty"`
+ // Protocol - The protocol of the end point. Possible values are: 'Http' or 'Tcp'. If 'Tcp' is specified, a received ACK is required for the probe to be successful. If 'Http' is specified, a 200 OK response from the specifies URI is required for the probe to be successful. Possible values include: 'ProbeProtocolHTTP', 'ProbeProtocolTCP'
+ Protocol ProbeProtocol `json:"protocol,omitempty"`
+ // Port - The port for communicating the probe. Possible values range from 1 to 65535, inclusive.
+ Port *int32 `json:"port,omitempty"`
+ // IntervalInSeconds - The interval, in seconds, for how frequently to probe the endpoint for health status. Typically, the interval is slightly less than half the allocated timeout period (in seconds) which allows two full probes before taking the instance out of rotation. The default value is 15, the minimum value is 5.
+ IntervalInSeconds *int32 `json:"intervalInSeconds,omitempty"`
+ // NumberOfProbes - The number of probes where if no response, will result in stopping further traffic from being delivered to the endpoint. This values allows endpoints to be taken out of rotation faster or slower than the typical times used in Azure.
+ NumberOfProbes *int32 `json:"numberOfProbes,omitempty"`
+ // RequestPath - The URI used for requesting health status from the VM. Path is required if a protocol is set to http. Otherwise, it is not allowed. There is no default value.
+ RequestPath *string `json:"requestPath,omitempty"`
+ // ProvisioningState - Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ProbePropertiesFormat.
+func (ppf ProbePropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ppf.Protocol != "" {
+ objectMap["protocol"] = ppf.Protocol
+ }
+ if ppf.Port != nil {
+ objectMap["port"] = ppf.Port
+ }
+ if ppf.IntervalInSeconds != nil {
+ objectMap["intervalInSeconds"] = ppf.IntervalInSeconds
+ }
+ if ppf.NumberOfProbes != nil {
+ objectMap["numberOfProbes"] = ppf.NumberOfProbes
+ }
+ if ppf.RequestPath != nil {
+ objectMap["requestPath"] = ppf.RequestPath
+ }
+ if ppf.ProvisioningState != nil {
+ objectMap["provisioningState"] = ppf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// PublicIPAddress public IP address resource.
+type PublicIPAddress struct {
+ autorest.Response `json:"-"`
+ // Sku - The public IP address SKU.
+ Sku *PublicIPAddressSku `json:"sku,omitempty"`
+ // PublicIPAddressPropertiesFormat - Public IP address properties.
+ *PublicIPAddressPropertiesFormat `json:"properties,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Zones - A list of availability zones denoting the IP allocated for the resource needs to come from.
+ Zones *[]string `json:"zones,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for PublicIPAddress.
+func (pia PublicIPAddress) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if pia.Sku != nil {
+ objectMap["sku"] = pia.Sku
+ }
+ if pia.PublicIPAddressPropertiesFormat != nil {
+ objectMap["properties"] = pia.PublicIPAddressPropertiesFormat
+ }
+ if pia.Etag != nil {
+ objectMap["etag"] = pia.Etag
+ }
+ if pia.Zones != nil {
+ objectMap["zones"] = pia.Zones
+ }
+ if pia.ID != nil {
+ objectMap["id"] = pia.ID
+ }
+ if pia.Location != nil {
+ objectMap["location"] = pia.Location
+ }
+ if pia.Tags != nil {
+ objectMap["tags"] = pia.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for PublicIPAddress struct.
+func (pia *PublicIPAddress) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku PublicIPAddressSku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ pia.Sku = &sku
+ }
+ case "properties":
+ if v != nil {
+ var publicIPAddressPropertiesFormat PublicIPAddressPropertiesFormat
+ err = json.Unmarshal(*v, &publicIPAddressPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ pia.PublicIPAddressPropertiesFormat = &publicIPAddressPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ pia.Etag = &etag
+ }
+ case "zones":
+ if v != nil {
+ var zones []string
+ err = json.Unmarshal(*v, &zones)
+ if err != nil {
+ return err
+ }
+ pia.Zones = &zones
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ pia.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ pia.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ pia.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ pia.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ pia.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// PublicIPAddressDNSSettings contains FQDN of the DNS record associated with the public IP address
+type PublicIPAddressDNSSettings struct {
+ // DomainNameLabel - Gets or sets the Domain name label.The concatenation of the domain name label and the regionalized DNS zone make up the fully qualified domain name associated with the public IP address. If a domain name label is specified, an A DNS record is created for the public IP in the Microsoft Azure DNS system.
+ DomainNameLabel *string `json:"domainNameLabel,omitempty"`
+ // Fqdn - Gets the FQDN, Fully qualified domain name of the A DNS record associated with the public IP. This is the concatenation of the domainNameLabel and the regionalized DNS zone.
+ Fqdn *string `json:"fqdn,omitempty"`
+ // ReverseFqdn - Gets or Sets the Reverse FQDN. A user-visible, fully qualified domain name that resolves to this public IP address. If the reverseFqdn is specified, then a PTR DNS record is created pointing from the IP address in the in-addr.arpa domain to the reverse FQDN.
+ ReverseFqdn *string `json:"reverseFqdn,omitempty"`
+}
+
+// PublicIPAddressesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type PublicIPAddressesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(PublicIPAddressesClient) (PublicIPAddress, error)
+}
+
+// PublicIPAddressesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type PublicIPAddressesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(PublicIPAddressesClient) (autorest.Response, error)
+}
+
+// PublicIPAddressesUpdateTagsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type PublicIPAddressesUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(PublicIPAddressesClient) (PublicIPAddress, error)
+}
+
+// PublicIPAddressListResult response for ListPublicIpAddresses API service call.
+type PublicIPAddressListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of public IP addresses that exists in a resource group.
+ Value *[]PublicIPAddress `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// PublicIPAddressListResultIterator provides access to a complete listing of PublicIPAddress values.
+type PublicIPAddressListResultIterator struct {
+ i int
+ page PublicIPAddressListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *PublicIPAddressListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *PublicIPAddressListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter PublicIPAddressListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter PublicIPAddressListResultIterator) Response() PublicIPAddressListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter PublicIPAddressListResultIterator) Value() PublicIPAddress {
+ if !iter.page.NotDone() {
+ return PublicIPAddress{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the PublicIPAddressListResultIterator type.
+func NewPublicIPAddressListResultIterator(page PublicIPAddressListResultPage) PublicIPAddressListResultIterator {
+ return PublicIPAddressListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (pialr PublicIPAddressListResult) IsEmpty() bool {
+ return pialr.Value == nil || len(*pialr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (pialr PublicIPAddressListResult) hasNextLink() bool {
+ return pialr.NextLink != nil && len(*pialr.NextLink) != 0
+}
+
+// publicIPAddressListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (pialr PublicIPAddressListResult) publicIPAddressListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !pialr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(pialr.NextLink)))
+}
+
+// PublicIPAddressListResultPage contains a page of PublicIPAddress values.
+type PublicIPAddressListResultPage struct {
+ fn func(context.Context, PublicIPAddressListResult) (PublicIPAddressListResult, error)
+ pialr PublicIPAddressListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *PublicIPAddressListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.pialr)
+ if err != nil {
+ return err
+ }
+ page.pialr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *PublicIPAddressListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page PublicIPAddressListResultPage) NotDone() bool {
+ return !page.pialr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page PublicIPAddressListResultPage) Response() PublicIPAddressListResult {
+ return page.pialr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page PublicIPAddressListResultPage) Values() []PublicIPAddress {
+ if page.pialr.IsEmpty() {
+ return nil
+ }
+ return *page.pialr.Value
+}
+
+// Creates a new instance of the PublicIPAddressListResultPage type.
+func NewPublicIPAddressListResultPage(cur PublicIPAddressListResult, getNextPage func(context.Context, PublicIPAddressListResult) (PublicIPAddressListResult, error)) PublicIPAddressListResultPage {
+ return PublicIPAddressListResultPage{
+ fn: getNextPage,
+ pialr: cur,
+ }
+}
+
+// PublicIPAddressPropertiesFormat public IP address properties.
+type PublicIPAddressPropertiesFormat struct {
+ // PublicIPAllocationMethod - The public IP allocation method. Possible values are: 'Static' and 'Dynamic'. Possible values include: 'Static', 'Dynamic'
+ PublicIPAllocationMethod IPAllocationMethod `json:"publicIPAllocationMethod,omitempty"`
+ // PublicIPAddressVersion - The public IP address version. Possible values are: 'IPv4' and 'IPv6'. Possible values include: 'IPv4', 'IPv6'
+ PublicIPAddressVersion IPVersion `json:"publicIPAddressVersion,omitempty"`
+ // IPConfiguration - READ-ONLY; The IP configuration associated with the public IP address.
+ IPConfiguration *IPConfiguration `json:"ipConfiguration,omitempty"`
+ // DNSSettings - The FQDN of the DNS record associated with the public IP address.
+ DNSSettings *PublicIPAddressDNSSettings `json:"dnsSettings,omitempty"`
+ // IPAddress - The IP address associated with the public IP address resource.
+ IPAddress *string `json:"ipAddress,omitempty"`
+ // IdleTimeoutInMinutes - The idle timeout of the public IP address.
+ IdleTimeoutInMinutes *int32 `json:"idleTimeoutInMinutes,omitempty"`
+ // ResourceGUID - The resource GUID property of the public IP resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - The provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for PublicIPAddressPropertiesFormat.
+func (piapf PublicIPAddressPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if piapf.PublicIPAllocationMethod != "" {
+ objectMap["publicIPAllocationMethod"] = piapf.PublicIPAllocationMethod
+ }
+ if piapf.PublicIPAddressVersion != "" {
+ objectMap["publicIPAddressVersion"] = piapf.PublicIPAddressVersion
+ }
+ if piapf.DNSSettings != nil {
+ objectMap["dnsSettings"] = piapf.DNSSettings
+ }
+ if piapf.IPAddress != nil {
+ objectMap["ipAddress"] = piapf.IPAddress
+ }
+ if piapf.IdleTimeoutInMinutes != nil {
+ objectMap["idleTimeoutInMinutes"] = piapf.IdleTimeoutInMinutes
+ }
+ if piapf.ResourceGUID != nil {
+ objectMap["resourceGuid"] = piapf.ResourceGUID
+ }
+ if piapf.ProvisioningState != nil {
+ objectMap["provisioningState"] = piapf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// PublicIPAddressSku SKU of a public IP address
+type PublicIPAddressSku struct {
+ // Name - Name of a public IP address SKU. Possible values include: 'PublicIPAddressSkuNameBasic', 'PublicIPAddressSkuNameStandard'
+ Name PublicIPAddressSkuName `json:"name,omitempty"`
+}
+
+// QueryTroubleshootingParameters parameters that define the resource to query the troubleshooting result.
+type QueryTroubleshootingParameters struct {
+ // TargetResourceID - The target resource ID to query the troubleshooting result.
+ TargetResourceID *string `json:"targetResourceId,omitempty"`
+}
+
+// Resource common resource representation.
+type Resource struct {
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Resource.
+func (r Resource) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if r.ID != nil {
+ objectMap["id"] = r.ID
+ }
+ if r.Location != nil {
+ objectMap["location"] = r.Location
+ }
+ if r.Tags != nil {
+ objectMap["tags"] = r.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// ResourceNavigationLink resourceNavigationLink resource.
+type ResourceNavigationLink struct {
+ // ResourceNavigationLinkFormat - Resource navigation link properties format.
+ *ResourceNavigationLinkFormat `json:"properties,omitempty"`
+ // Name - Name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - READ-ONLY; A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ResourceNavigationLink.
+func (rnl ResourceNavigationLink) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rnl.ResourceNavigationLinkFormat != nil {
+ objectMap["properties"] = rnl.ResourceNavigationLinkFormat
+ }
+ if rnl.Name != nil {
+ objectMap["name"] = rnl.Name
+ }
+ if rnl.ID != nil {
+ objectMap["id"] = rnl.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ResourceNavigationLink struct.
+func (rnl *ResourceNavigationLink) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var resourceNavigationLinkFormat ResourceNavigationLinkFormat
+ err = json.Unmarshal(*v, &resourceNavigationLinkFormat)
+ if err != nil {
+ return err
+ }
+ rnl.ResourceNavigationLinkFormat = &resourceNavigationLinkFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ rnl.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ rnl.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ rnl.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// ResourceNavigationLinkFormat properties of ResourceNavigationLink.
+type ResourceNavigationLinkFormat struct {
+ // LinkedResourceType - Resource type of the linked resource.
+ LinkedResourceType *string `json:"linkedResourceType,omitempty"`
+ // Link - Link to the external resource
+ Link *string `json:"link,omitempty"`
+ // ProvisioningState - READ-ONLY; Provisioning state of the ResourceNavigationLink resource.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ResourceNavigationLinkFormat.
+func (rnlf ResourceNavigationLinkFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rnlf.LinkedResourceType != nil {
+ objectMap["linkedResourceType"] = rnlf.LinkedResourceType
+ }
+ if rnlf.Link != nil {
+ objectMap["link"] = rnlf.Link
+ }
+ return json.Marshal(objectMap)
+}
+
+// RetentionPolicyParameters parameters that define the retention policy for flow log.
+type RetentionPolicyParameters struct {
+ // Days - Number of days to retain flow log records.
+ Days *int32 `json:"days,omitempty"`
+ // Enabled - Flag to enable/disable retention.
+ Enabled *bool `json:"enabled,omitempty"`
+}
+
+// Route route resource
+type Route struct {
+ autorest.Response `json:"-"`
+ // RoutePropertiesFormat - Properties of the route.
+ *RoutePropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Route.
+func (r Route) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if r.RoutePropertiesFormat != nil {
+ objectMap["properties"] = r.RoutePropertiesFormat
+ }
+ if r.Name != nil {
+ objectMap["name"] = r.Name
+ }
+ if r.Etag != nil {
+ objectMap["etag"] = r.Etag
+ }
+ if r.ID != nil {
+ objectMap["id"] = r.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Route struct.
+func (r *Route) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var routePropertiesFormat RoutePropertiesFormat
+ err = json.Unmarshal(*v, &routePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ r.RoutePropertiesFormat = &routePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ r.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ r.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ r.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// RouteFilter route Filter Resource.
+type RouteFilter struct {
+ autorest.Response `json:"-"`
+ *RouteFilterPropertiesFormat `json:"properties,omitempty"`
+ // Etag - READ-ONLY; Gets a unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for RouteFilter.
+func (rf RouteFilter) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rf.RouteFilterPropertiesFormat != nil {
+ objectMap["properties"] = rf.RouteFilterPropertiesFormat
+ }
+ if rf.ID != nil {
+ objectMap["id"] = rf.ID
+ }
+ if rf.Location != nil {
+ objectMap["location"] = rf.Location
+ }
+ if rf.Tags != nil {
+ objectMap["tags"] = rf.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for RouteFilter struct.
+func (rf *RouteFilter) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var routeFilterPropertiesFormat RouteFilterPropertiesFormat
+ err = json.Unmarshal(*v, &routeFilterPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ rf.RouteFilterPropertiesFormat = &routeFilterPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ rf.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ rf.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ rf.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ rf.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ rf.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ rf.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// RouteFilterListResult response for the ListRouteFilters API service call.
+type RouteFilterListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of route filters in a resource group.
+ Value *[]RouteFilter `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// RouteFilterListResultIterator provides access to a complete listing of RouteFilter values.
+type RouteFilterListResultIterator struct {
+ i int
+ page RouteFilterListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *RouteFilterListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *RouteFilterListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter RouteFilterListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter RouteFilterListResultIterator) Response() RouteFilterListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter RouteFilterListResultIterator) Value() RouteFilter {
+ if !iter.page.NotDone() {
+ return RouteFilter{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the RouteFilterListResultIterator type.
+func NewRouteFilterListResultIterator(page RouteFilterListResultPage) RouteFilterListResultIterator {
+ return RouteFilterListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (rflr RouteFilterListResult) IsEmpty() bool {
+ return rflr.Value == nil || len(*rflr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (rflr RouteFilterListResult) hasNextLink() bool {
+ return rflr.NextLink != nil && len(*rflr.NextLink) != 0
+}
+
+// routeFilterListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (rflr RouteFilterListResult) routeFilterListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !rflr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(rflr.NextLink)))
+}
+
+// RouteFilterListResultPage contains a page of RouteFilter values.
+type RouteFilterListResultPage struct {
+ fn func(context.Context, RouteFilterListResult) (RouteFilterListResult, error)
+ rflr RouteFilterListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *RouteFilterListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.rflr)
+ if err != nil {
+ return err
+ }
+ page.rflr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *RouteFilterListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page RouteFilterListResultPage) NotDone() bool {
+ return !page.rflr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page RouteFilterListResultPage) Response() RouteFilterListResult {
+ return page.rflr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page RouteFilterListResultPage) Values() []RouteFilter {
+ if page.rflr.IsEmpty() {
+ return nil
+ }
+ return *page.rflr.Value
+}
+
+// Creates a new instance of the RouteFilterListResultPage type.
+func NewRouteFilterListResultPage(cur RouteFilterListResult, getNextPage func(context.Context, RouteFilterListResult) (RouteFilterListResult, error)) RouteFilterListResultPage {
+ return RouteFilterListResultPage{
+ fn: getNextPage,
+ rflr: cur,
+ }
+}
+
+// RouteFilterPropertiesFormat route Filter Resource
+type RouteFilterPropertiesFormat struct {
+ // Rules - Collection of RouteFilterRules contained within a route filter.
+ Rules *[]RouteFilterRule `json:"rules,omitempty"`
+ // Peerings - A collection of references to express route circuit peerings.
+ Peerings *[]ExpressRouteCircuitPeering `json:"peerings,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', 'Succeeded' and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for RouteFilterPropertiesFormat.
+func (rfpf RouteFilterPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rfpf.Rules != nil {
+ objectMap["rules"] = rfpf.Rules
+ }
+ if rfpf.Peerings != nil {
+ objectMap["peerings"] = rfpf.Peerings
+ }
+ return json.Marshal(objectMap)
+}
+
+// RouteFilterRule route Filter Rule Resource
+type RouteFilterRule struct {
+ autorest.Response `json:"-"`
+ *RouteFilterRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Etag - READ-ONLY; A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for RouteFilterRule.
+func (rfr RouteFilterRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rfr.RouteFilterRulePropertiesFormat != nil {
+ objectMap["properties"] = rfr.RouteFilterRulePropertiesFormat
+ }
+ if rfr.Name != nil {
+ objectMap["name"] = rfr.Name
+ }
+ if rfr.Location != nil {
+ objectMap["location"] = rfr.Location
+ }
+ if rfr.Tags != nil {
+ objectMap["tags"] = rfr.Tags
+ }
+ if rfr.ID != nil {
+ objectMap["id"] = rfr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for RouteFilterRule struct.
+func (rfr *RouteFilterRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var routeFilterRulePropertiesFormat RouteFilterRulePropertiesFormat
+ err = json.Unmarshal(*v, &routeFilterRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ rfr.RouteFilterRulePropertiesFormat = &routeFilterRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ rfr.Name = &name
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ rfr.Location = &location
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ rfr.Etag = &etag
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ rfr.Tags = tags
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ rfr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// RouteFilterRuleListResult response for the ListRouteFilterRules API service call
+type RouteFilterRuleListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of RouteFilterRules in a resource group.
+ Value *[]RouteFilterRule `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// RouteFilterRuleListResultIterator provides access to a complete listing of RouteFilterRule values.
+type RouteFilterRuleListResultIterator struct {
+ i int
+ page RouteFilterRuleListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *RouteFilterRuleListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRuleListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *RouteFilterRuleListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter RouteFilterRuleListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter RouteFilterRuleListResultIterator) Response() RouteFilterRuleListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter RouteFilterRuleListResultIterator) Value() RouteFilterRule {
+ if !iter.page.NotDone() {
+ return RouteFilterRule{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the RouteFilterRuleListResultIterator type.
+func NewRouteFilterRuleListResultIterator(page RouteFilterRuleListResultPage) RouteFilterRuleListResultIterator {
+ return RouteFilterRuleListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (rfrlr RouteFilterRuleListResult) IsEmpty() bool {
+ return rfrlr.Value == nil || len(*rfrlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (rfrlr RouteFilterRuleListResult) hasNextLink() bool {
+ return rfrlr.NextLink != nil && len(*rfrlr.NextLink) != 0
+}
+
+// routeFilterRuleListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (rfrlr RouteFilterRuleListResult) routeFilterRuleListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !rfrlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(rfrlr.NextLink)))
+}
+
+// RouteFilterRuleListResultPage contains a page of RouteFilterRule values.
+type RouteFilterRuleListResultPage struct {
+ fn func(context.Context, RouteFilterRuleListResult) (RouteFilterRuleListResult, error)
+ rfrlr RouteFilterRuleListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *RouteFilterRuleListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRuleListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.rfrlr)
+ if err != nil {
+ return err
+ }
+ page.rfrlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *RouteFilterRuleListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page RouteFilterRuleListResultPage) NotDone() bool {
+ return !page.rfrlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page RouteFilterRuleListResultPage) Response() RouteFilterRuleListResult {
+ return page.rfrlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page RouteFilterRuleListResultPage) Values() []RouteFilterRule {
+ if page.rfrlr.IsEmpty() {
+ return nil
+ }
+ return *page.rfrlr.Value
+}
+
+// Creates a new instance of the RouteFilterRuleListResultPage type.
+func NewRouteFilterRuleListResultPage(cur RouteFilterRuleListResult, getNextPage func(context.Context, RouteFilterRuleListResult) (RouteFilterRuleListResult, error)) RouteFilterRuleListResultPage {
+ return RouteFilterRuleListResultPage{
+ fn: getNextPage,
+ rfrlr: cur,
+ }
+}
+
+// RouteFilterRulePropertiesFormat route Filter Rule Resource
+type RouteFilterRulePropertiesFormat struct {
+ // Access - The access type of the rule. Valid values are: 'Allow', 'Deny'. Possible values include: 'Allow', 'Deny'
+ Access Access `json:"access,omitempty"`
+ // RouteFilterRuleType - The rule type of the rule. Valid value is: 'Community'
+ RouteFilterRuleType *string `json:"routeFilterRuleType,omitempty"`
+ // Communities - The collection for bgp community values to filter on. e.g. ['12076:5010','12076:5020']
+ Communities *[]string `json:"communities,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', 'Succeeded' and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for RouteFilterRulePropertiesFormat.
+func (rfrpf RouteFilterRulePropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rfrpf.Access != "" {
+ objectMap["access"] = rfrpf.Access
+ }
+ if rfrpf.RouteFilterRuleType != nil {
+ objectMap["routeFilterRuleType"] = rfrpf.RouteFilterRuleType
+ }
+ if rfrpf.Communities != nil {
+ objectMap["communities"] = rfrpf.Communities
+ }
+ return json.Marshal(objectMap)
+}
+
+// RouteFilterRulesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type RouteFilterRulesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteFilterRulesClient) (RouteFilterRule, error)
+}
+
+// RouteFilterRulesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type RouteFilterRulesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteFilterRulesClient) (autorest.Response, error)
+}
+
+// RouteFilterRulesUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type RouteFilterRulesUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteFilterRulesClient) (RouteFilterRule, error)
+}
+
+// RouteFiltersCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type RouteFiltersCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteFiltersClient) (RouteFilter, error)
+}
+
+// RouteFiltersDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type RouteFiltersDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteFiltersClient) (autorest.Response, error)
+}
+
+// RouteFiltersUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type RouteFiltersUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteFiltersClient) (RouteFilter, error)
+}
+
+// RouteListResult response for the ListRoute API service call
+type RouteListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of routes in a resource group.
+ Value *[]Route `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// RouteListResultIterator provides access to a complete listing of Route values.
+type RouteListResultIterator struct {
+ i int
+ page RouteListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *RouteListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *RouteListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter RouteListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter RouteListResultIterator) Response() RouteListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter RouteListResultIterator) Value() Route {
+ if !iter.page.NotDone() {
+ return Route{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the RouteListResultIterator type.
+func NewRouteListResultIterator(page RouteListResultPage) RouteListResultIterator {
+ return RouteListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (rlr RouteListResult) IsEmpty() bool {
+ return rlr.Value == nil || len(*rlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (rlr RouteListResult) hasNextLink() bool {
+ return rlr.NextLink != nil && len(*rlr.NextLink) != 0
+}
+
+// routeListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (rlr RouteListResult) routeListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !rlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(rlr.NextLink)))
+}
+
+// RouteListResultPage contains a page of Route values.
+type RouteListResultPage struct {
+ fn func(context.Context, RouteListResult) (RouteListResult, error)
+ rlr RouteListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *RouteListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.rlr)
+ if err != nil {
+ return err
+ }
+ page.rlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *RouteListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page RouteListResultPage) NotDone() bool {
+ return !page.rlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page RouteListResultPage) Response() RouteListResult {
+ return page.rlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page RouteListResultPage) Values() []Route {
+ if page.rlr.IsEmpty() {
+ return nil
+ }
+ return *page.rlr.Value
+}
+
+// Creates a new instance of the RouteListResultPage type.
+func NewRouteListResultPage(cur RouteListResult, getNextPage func(context.Context, RouteListResult) (RouteListResult, error)) RouteListResultPage {
+ return RouteListResultPage{
+ fn: getNextPage,
+ rlr: cur,
+ }
+}
+
+// RoutePropertiesFormat route resource
+type RoutePropertiesFormat struct {
+ // AddressPrefix - The destination CIDR to which the route applies.
+ AddressPrefix *string `json:"addressPrefix,omitempty"`
+ // NextHopType - The type of Azure hop the packet should be sent to. Possible values are: 'VirtualNetworkGateway', 'VnetLocal', 'Internet', 'VirtualAppliance', and 'None'. Possible values include: 'RouteNextHopTypeVirtualNetworkGateway', 'RouteNextHopTypeVnetLocal', 'RouteNextHopTypeInternet', 'RouteNextHopTypeVirtualAppliance', 'RouteNextHopTypeNone'
+ NextHopType RouteNextHopType `json:"nextHopType,omitempty"`
+ // NextHopIPAddress - The IP address packets should be forwarded to. Next hop values are only allowed in routes where the next hop type is VirtualAppliance.
+ NextHopIPAddress *string `json:"nextHopIpAddress,omitempty"`
+ // ProvisioningState - The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// RoutesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type RoutesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RoutesClient) (Route, error)
+}
+
+// RoutesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running operation.
+type RoutesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RoutesClient) (autorest.Response, error)
+}
+
+// RouteTable route table resource.
+type RouteTable struct {
+ autorest.Response `json:"-"`
+ // RouteTablePropertiesFormat - Properties of the route table.
+ *RouteTablePropertiesFormat `json:"properties,omitempty"`
+ // Etag - Gets a unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for RouteTable.
+func (rt RouteTable) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rt.RouteTablePropertiesFormat != nil {
+ objectMap["properties"] = rt.RouteTablePropertiesFormat
+ }
+ if rt.Etag != nil {
+ objectMap["etag"] = rt.Etag
+ }
+ if rt.ID != nil {
+ objectMap["id"] = rt.ID
+ }
+ if rt.Location != nil {
+ objectMap["location"] = rt.Location
+ }
+ if rt.Tags != nil {
+ objectMap["tags"] = rt.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for RouteTable struct.
+func (rt *RouteTable) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var routeTablePropertiesFormat RouteTablePropertiesFormat
+ err = json.Unmarshal(*v, &routeTablePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ rt.RouteTablePropertiesFormat = &routeTablePropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ rt.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ rt.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ rt.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ rt.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ rt.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ rt.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// RouteTableListResult response for the ListRouteTable API service call.
+type RouteTableListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of route tables in a resource group.
+ Value *[]RouteTable `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// RouteTableListResultIterator provides access to a complete listing of RouteTable values.
+type RouteTableListResultIterator struct {
+ i int
+ page RouteTableListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *RouteTableListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTableListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *RouteTableListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter RouteTableListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter RouteTableListResultIterator) Response() RouteTableListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter RouteTableListResultIterator) Value() RouteTable {
+ if !iter.page.NotDone() {
+ return RouteTable{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the RouteTableListResultIterator type.
+func NewRouteTableListResultIterator(page RouteTableListResultPage) RouteTableListResultIterator {
+ return RouteTableListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (rtlr RouteTableListResult) IsEmpty() bool {
+ return rtlr.Value == nil || len(*rtlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (rtlr RouteTableListResult) hasNextLink() bool {
+ return rtlr.NextLink != nil && len(*rtlr.NextLink) != 0
+}
+
+// routeTableListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (rtlr RouteTableListResult) routeTableListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !rtlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(rtlr.NextLink)))
+}
+
+// RouteTableListResultPage contains a page of RouteTable values.
+type RouteTableListResultPage struct {
+ fn func(context.Context, RouteTableListResult) (RouteTableListResult, error)
+ rtlr RouteTableListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *RouteTableListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTableListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.rtlr)
+ if err != nil {
+ return err
+ }
+ page.rtlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *RouteTableListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page RouteTableListResultPage) NotDone() bool {
+ return !page.rtlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page RouteTableListResultPage) Response() RouteTableListResult {
+ return page.rtlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page RouteTableListResultPage) Values() []RouteTable {
+ if page.rtlr.IsEmpty() {
+ return nil
+ }
+ return *page.rtlr.Value
+}
+
+// Creates a new instance of the RouteTableListResultPage type.
+func NewRouteTableListResultPage(cur RouteTableListResult, getNextPage func(context.Context, RouteTableListResult) (RouteTableListResult, error)) RouteTableListResultPage {
+ return RouteTableListResultPage{
+ fn: getNextPage,
+ rtlr: cur,
+ }
+}
+
+// RouteTablePropertiesFormat route Table resource
+type RouteTablePropertiesFormat struct {
+ // Routes - Collection of routes contained within a route table.
+ Routes *[]Route `json:"routes,omitempty"`
+ // Subnets - READ-ONLY; A collection of references to subnets.
+ Subnets *[]Subnet `json:"subnets,omitempty"`
+ // DisableBgpRoutePropagation - Gets or sets whether to disable the routes learned by BGP on that route table. True means disable.
+ DisableBgpRoutePropagation *bool `json:"disableBgpRoutePropagation,omitempty"`
+ // ProvisioningState - The provisioning state of the resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for RouteTablePropertiesFormat.
+func (rtpf RouteTablePropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rtpf.Routes != nil {
+ objectMap["routes"] = rtpf.Routes
+ }
+ if rtpf.DisableBgpRoutePropagation != nil {
+ objectMap["disableBgpRoutePropagation"] = rtpf.DisableBgpRoutePropagation
+ }
+ if rtpf.ProvisioningState != nil {
+ objectMap["provisioningState"] = rtpf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// RouteTablesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type RouteTablesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteTablesClient) (RouteTable, error)
+}
+
+// RouteTablesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type RouteTablesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteTablesClient) (autorest.Response, error)
+}
+
+// RouteTablesUpdateTagsFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type RouteTablesUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(RouteTablesClient) (RouteTable, error)
+}
+
+// SecurityGroup networkSecurityGroup resource.
+type SecurityGroup struct {
+ autorest.Response `json:"-"`
+ // SecurityGroupPropertiesFormat - Properties of the network security group
+ *SecurityGroupPropertiesFormat `json:"properties,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for SecurityGroup.
+func (sg SecurityGroup) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if sg.SecurityGroupPropertiesFormat != nil {
+ objectMap["properties"] = sg.SecurityGroupPropertiesFormat
+ }
+ if sg.Etag != nil {
+ objectMap["etag"] = sg.Etag
+ }
+ if sg.ID != nil {
+ objectMap["id"] = sg.ID
+ }
+ if sg.Location != nil {
+ objectMap["location"] = sg.Location
+ }
+ if sg.Tags != nil {
+ objectMap["tags"] = sg.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for SecurityGroup struct.
+func (sg *SecurityGroup) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var securityGroupPropertiesFormat SecurityGroupPropertiesFormat
+ err = json.Unmarshal(*v, &securityGroupPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ sg.SecurityGroupPropertiesFormat = &securityGroupPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ sg.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ sg.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ sg.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ sg.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ sg.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ sg.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// SecurityGroupListResult response for ListNetworkSecurityGroups API service call.
+type SecurityGroupListResult struct {
+ autorest.Response `json:"-"`
+ // Value - A list of NetworkSecurityGroup resources.
+ Value *[]SecurityGroup `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SecurityGroupListResultIterator provides access to a complete listing of SecurityGroup values.
+type SecurityGroupListResultIterator struct {
+ i int
+ page SecurityGroupListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *SecurityGroupListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *SecurityGroupListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter SecurityGroupListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter SecurityGroupListResultIterator) Response() SecurityGroupListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter SecurityGroupListResultIterator) Value() SecurityGroup {
+ if !iter.page.NotDone() {
+ return SecurityGroup{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the SecurityGroupListResultIterator type.
+func NewSecurityGroupListResultIterator(page SecurityGroupListResultPage) SecurityGroupListResultIterator {
+ return SecurityGroupListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (sglr SecurityGroupListResult) IsEmpty() bool {
+ return sglr.Value == nil || len(*sglr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (sglr SecurityGroupListResult) hasNextLink() bool {
+ return sglr.NextLink != nil && len(*sglr.NextLink) != 0
+}
+
+// securityGroupListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (sglr SecurityGroupListResult) securityGroupListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !sglr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(sglr.NextLink)))
+}
+
+// SecurityGroupListResultPage contains a page of SecurityGroup values.
+type SecurityGroupListResultPage struct {
+ fn func(context.Context, SecurityGroupListResult) (SecurityGroupListResult, error)
+ sglr SecurityGroupListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *SecurityGroupListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.sglr)
+ if err != nil {
+ return err
+ }
+ page.sglr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *SecurityGroupListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page SecurityGroupListResultPage) NotDone() bool {
+ return !page.sglr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page SecurityGroupListResultPage) Response() SecurityGroupListResult {
+ return page.sglr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page SecurityGroupListResultPage) Values() []SecurityGroup {
+ if page.sglr.IsEmpty() {
+ return nil
+ }
+ return *page.sglr.Value
+}
+
+// Creates a new instance of the SecurityGroupListResultPage type.
+func NewSecurityGroupListResultPage(cur SecurityGroupListResult, getNextPage func(context.Context, SecurityGroupListResult) (SecurityGroupListResult, error)) SecurityGroupListResultPage {
+ return SecurityGroupListResultPage{
+ fn: getNextPage,
+ sglr: cur,
+ }
+}
+
+// SecurityGroupNetworkInterface network interface and all its associated security rules.
+type SecurityGroupNetworkInterface struct {
+ // ID - ID of the network interface.
+ ID *string `json:"id,omitempty"`
+ SecurityRuleAssociations *SecurityRuleAssociations `json:"securityRuleAssociations,omitempty"`
+}
+
+// SecurityGroupPropertiesFormat network Security Group resource.
+type SecurityGroupPropertiesFormat struct {
+ // SecurityRules - A collection of security rules of the network security group.
+ SecurityRules *[]SecurityRule `json:"securityRules,omitempty"`
+ // DefaultSecurityRules - The default security rules of network security group.
+ DefaultSecurityRules *[]SecurityRule `json:"defaultSecurityRules,omitempty"`
+ // NetworkInterfaces - READ-ONLY; A collection of references to network interfaces.
+ NetworkInterfaces *[]Interface `json:"networkInterfaces,omitempty"`
+ // Subnets - READ-ONLY; A collection of references to subnets.
+ Subnets *[]Subnet `json:"subnets,omitempty"`
+ // ResourceGUID - The resource GUID property of the network security group resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for SecurityGroupPropertiesFormat.
+func (sgpf SecurityGroupPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if sgpf.SecurityRules != nil {
+ objectMap["securityRules"] = sgpf.SecurityRules
+ }
+ if sgpf.DefaultSecurityRules != nil {
+ objectMap["defaultSecurityRules"] = sgpf.DefaultSecurityRules
+ }
+ if sgpf.ResourceGUID != nil {
+ objectMap["resourceGuid"] = sgpf.ResourceGUID
+ }
+ if sgpf.ProvisioningState != nil {
+ objectMap["provisioningState"] = sgpf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// SecurityGroupsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type SecurityGroupsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SecurityGroupsClient) (SecurityGroup, error)
+}
+
+// SecurityGroupsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SecurityGroupsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SecurityGroupsClient) (autorest.Response, error)
+}
+
+// SecurityGroupsUpdateTagsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type SecurityGroupsUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SecurityGroupsClient) (SecurityGroup, error)
+}
+
+// SecurityGroupViewParameters parameters that define the VM to check security groups for.
+type SecurityGroupViewParameters struct {
+ // TargetResourceID - ID of the target VM.
+ TargetResourceID *string `json:"targetResourceId,omitempty"`
+}
+
+// SecurityGroupViewResult the information about security rules applied to the specified VM.
+type SecurityGroupViewResult struct {
+ autorest.Response `json:"-"`
+ // NetworkInterfaces - List of network interfaces on the specified VM.
+ NetworkInterfaces *[]SecurityGroupNetworkInterface `json:"networkInterfaces,omitempty"`
+}
+
+// SecurityRule network security rule.
+type SecurityRule struct {
+ autorest.Response `json:"-"`
+ // SecurityRulePropertiesFormat - Properties of the security rule
+ *SecurityRulePropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for SecurityRule.
+func (sr SecurityRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if sr.SecurityRulePropertiesFormat != nil {
+ objectMap["properties"] = sr.SecurityRulePropertiesFormat
+ }
+ if sr.Name != nil {
+ objectMap["name"] = sr.Name
+ }
+ if sr.Etag != nil {
+ objectMap["etag"] = sr.Etag
+ }
+ if sr.ID != nil {
+ objectMap["id"] = sr.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for SecurityRule struct.
+func (sr *SecurityRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var securityRulePropertiesFormat SecurityRulePropertiesFormat
+ err = json.Unmarshal(*v, &securityRulePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ sr.SecurityRulePropertiesFormat = &securityRulePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ sr.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ sr.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ sr.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// SecurityRuleAssociations all security rules associated with the network interface.
+type SecurityRuleAssociations struct {
+ NetworkInterfaceAssociation *InterfaceAssociation `json:"networkInterfaceAssociation,omitempty"`
+ SubnetAssociation *SubnetAssociation `json:"subnetAssociation,omitempty"`
+ // DefaultSecurityRules - Collection of default security rules of the network security group.
+ DefaultSecurityRules *[]SecurityRule `json:"defaultSecurityRules,omitempty"`
+ // EffectiveSecurityRules - Collection of effective security rules.
+ EffectiveSecurityRules *[]EffectiveNetworkSecurityRule `json:"effectiveSecurityRules,omitempty"`
+}
+
+// SecurityRuleListResult response for ListSecurityRule API service call. Retrieves all security rules that
+// belongs to a network security group.
+type SecurityRuleListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The security rules in a network security group.
+ Value *[]SecurityRule `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SecurityRuleListResultIterator provides access to a complete listing of SecurityRule values.
+type SecurityRuleListResultIterator struct {
+ i int
+ page SecurityRuleListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *SecurityRuleListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityRuleListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *SecurityRuleListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter SecurityRuleListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter SecurityRuleListResultIterator) Response() SecurityRuleListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter SecurityRuleListResultIterator) Value() SecurityRule {
+ if !iter.page.NotDone() {
+ return SecurityRule{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the SecurityRuleListResultIterator type.
+func NewSecurityRuleListResultIterator(page SecurityRuleListResultPage) SecurityRuleListResultIterator {
+ return SecurityRuleListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (srlr SecurityRuleListResult) IsEmpty() bool {
+ return srlr.Value == nil || len(*srlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (srlr SecurityRuleListResult) hasNextLink() bool {
+ return srlr.NextLink != nil && len(*srlr.NextLink) != 0
+}
+
+// securityRuleListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (srlr SecurityRuleListResult) securityRuleListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !srlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(srlr.NextLink)))
+}
+
+// SecurityRuleListResultPage contains a page of SecurityRule values.
+type SecurityRuleListResultPage struct {
+ fn func(context.Context, SecurityRuleListResult) (SecurityRuleListResult, error)
+ srlr SecurityRuleListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *SecurityRuleListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityRuleListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.srlr)
+ if err != nil {
+ return err
+ }
+ page.srlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *SecurityRuleListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page SecurityRuleListResultPage) NotDone() bool {
+ return !page.srlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page SecurityRuleListResultPage) Response() SecurityRuleListResult {
+ return page.srlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page SecurityRuleListResultPage) Values() []SecurityRule {
+ if page.srlr.IsEmpty() {
+ return nil
+ }
+ return *page.srlr.Value
+}
+
+// Creates a new instance of the SecurityRuleListResultPage type.
+func NewSecurityRuleListResultPage(cur SecurityRuleListResult, getNextPage func(context.Context, SecurityRuleListResult) (SecurityRuleListResult, error)) SecurityRuleListResultPage {
+ return SecurityRuleListResultPage{
+ fn: getNextPage,
+ srlr: cur,
+ }
+}
+
+// SecurityRulePropertiesFormat security rule resource.
+type SecurityRulePropertiesFormat struct {
+ // Description - A description for this rule. Restricted to 140 chars.
+ Description *string `json:"description,omitempty"`
+ // Protocol - Network protocol this rule applies to. Possible values are 'Tcp', 'Udp', and '*'. Possible values include: 'SecurityRuleProtocolTCP', 'SecurityRuleProtocolUDP', 'SecurityRuleProtocolAsterisk'
+ Protocol SecurityRuleProtocol `json:"protocol,omitempty"`
+ // SourcePortRange - The source port or range. Integer or range between 0 and 65535. Asterisk '*' can also be used to match all ports.
+ SourcePortRange *string `json:"sourcePortRange,omitempty"`
+ // DestinationPortRange - The destination port or range. Integer or range between 0 and 65535. Asterisk '*' can also be used to match all ports.
+ DestinationPortRange *string `json:"destinationPortRange,omitempty"`
+ // SourceAddressPrefix - The CIDR or source IP range. Asterisk '*' can also be used to match all source IPs. Default tags such as 'VirtualNetwork', 'AzureLoadBalancer' and 'Internet' can also be used. If this is an ingress rule, specifies where network traffic originates from.
+ SourceAddressPrefix *string `json:"sourceAddressPrefix,omitempty"`
+ // SourceAddressPrefixes - The CIDR or source IP ranges.
+ SourceAddressPrefixes *[]string `json:"sourceAddressPrefixes,omitempty"`
+ // SourceApplicationSecurityGroups - The application security group specified as source.
+ SourceApplicationSecurityGroups *[]ApplicationSecurityGroup `json:"sourceApplicationSecurityGroups,omitempty"`
+ // DestinationAddressPrefix - The destination address prefix. CIDR or destination IP range. Asterisk '*' can also be used to match all source IPs. Default tags such as 'VirtualNetwork', 'AzureLoadBalancer' and 'Internet' can also be used.
+ DestinationAddressPrefix *string `json:"destinationAddressPrefix,omitempty"`
+ // DestinationAddressPrefixes - The destination address prefixes. CIDR or destination IP ranges.
+ DestinationAddressPrefixes *[]string `json:"destinationAddressPrefixes,omitempty"`
+ // DestinationApplicationSecurityGroups - The application security group specified as destination.
+ DestinationApplicationSecurityGroups *[]ApplicationSecurityGroup `json:"destinationApplicationSecurityGroups,omitempty"`
+ // SourcePortRanges - The source port ranges.
+ SourcePortRanges *[]string `json:"sourcePortRanges,omitempty"`
+ // DestinationPortRanges - The destination port ranges.
+ DestinationPortRanges *[]string `json:"destinationPortRanges,omitempty"`
+ // Access - The network traffic is allowed or denied. Possible values are: 'Allow' and 'Deny'. Possible values include: 'SecurityRuleAccessAllow', 'SecurityRuleAccessDeny'
+ Access SecurityRuleAccess `json:"access,omitempty"`
+ // Priority - The priority of the rule. The value can be between 100 and 4096. The priority number must be unique for each rule in the collection. The lower the priority number, the higher the priority of the rule.
+ Priority *int32 `json:"priority,omitempty"`
+ // Direction - The direction of the rule. The direction specifies if rule will be evaluated on incoming or outgoing traffic. Possible values are: 'Inbound' and 'Outbound'. Possible values include: 'SecurityRuleDirectionInbound', 'SecurityRuleDirectionOutbound'
+ Direction SecurityRuleDirection `json:"direction,omitempty"`
+ // ProvisioningState - The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// SecurityRulesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type SecurityRulesCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SecurityRulesClient) (SecurityRule, error)
+}
+
+// SecurityRulesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SecurityRulesDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SecurityRulesClient) (autorest.Response, error)
+}
+
+// ServiceEndpointPropertiesFormat the service endpoint properties.
+type ServiceEndpointPropertiesFormat struct {
+ // Service - The type of the endpoint service.
+ Service *string `json:"service,omitempty"`
+ // Locations - A list of locations.
+ Locations *[]string `json:"locations,omitempty"`
+ // ProvisioningState - The provisioning state of the resource.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// String ...
+type String struct {
+ autorest.Response `json:"-"`
+ Value *string `json:"value,omitempty"`
+}
+
+// Subnet subnet in a virtual network resource.
+type Subnet struct {
+ autorest.Response `json:"-"`
+ // SubnetPropertiesFormat - Properties of the subnet.
+ *SubnetPropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Subnet.
+func (s Subnet) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if s.SubnetPropertiesFormat != nil {
+ objectMap["properties"] = s.SubnetPropertiesFormat
+ }
+ if s.Name != nil {
+ objectMap["name"] = s.Name
+ }
+ if s.Etag != nil {
+ objectMap["etag"] = s.Etag
+ }
+ if s.ID != nil {
+ objectMap["id"] = s.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Subnet struct.
+func (s *Subnet) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var subnetPropertiesFormat SubnetPropertiesFormat
+ err = json.Unmarshal(*v, &subnetPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ s.SubnetPropertiesFormat = &subnetPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ s.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ s.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ s.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// SubnetAssociation network interface and its custom security rules.
+type SubnetAssociation struct {
+ // ID - READ-ONLY; Subnet ID.
+ ID *string `json:"id,omitempty"`
+ // SecurityRules - Collection of custom security rules.
+ SecurityRules *[]SecurityRule `json:"securityRules,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for SubnetAssociation.
+func (sa SubnetAssociation) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if sa.SecurityRules != nil {
+ objectMap["securityRules"] = sa.SecurityRules
+ }
+ return json.Marshal(objectMap)
+}
+
+// SubnetListResult response for ListSubnets API service callRetrieves all subnet that belongs to a virtual
+// network
+type SubnetListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The subnets in a virtual network.
+ Value *[]Subnet `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SubnetListResultIterator provides access to a complete listing of Subnet values.
+type SubnetListResultIterator struct {
+ i int
+ page SubnetListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *SubnetListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SubnetListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *SubnetListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter SubnetListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter SubnetListResultIterator) Response() SubnetListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter SubnetListResultIterator) Value() Subnet {
+ if !iter.page.NotDone() {
+ return Subnet{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the SubnetListResultIterator type.
+func NewSubnetListResultIterator(page SubnetListResultPage) SubnetListResultIterator {
+ return SubnetListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (slr SubnetListResult) IsEmpty() bool {
+ return slr.Value == nil || len(*slr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (slr SubnetListResult) hasNextLink() bool {
+ return slr.NextLink != nil && len(*slr.NextLink) != 0
+}
+
+// subnetListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (slr SubnetListResult) subnetListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !slr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(slr.NextLink)))
+}
+
+// SubnetListResultPage contains a page of Subnet values.
+type SubnetListResultPage struct {
+ fn func(context.Context, SubnetListResult) (SubnetListResult, error)
+ slr SubnetListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *SubnetListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SubnetListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.slr)
+ if err != nil {
+ return err
+ }
+ page.slr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *SubnetListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page SubnetListResultPage) NotDone() bool {
+ return !page.slr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page SubnetListResultPage) Response() SubnetListResult {
+ return page.slr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page SubnetListResultPage) Values() []Subnet {
+ if page.slr.IsEmpty() {
+ return nil
+ }
+ return *page.slr.Value
+}
+
+// Creates a new instance of the SubnetListResultPage type.
+func NewSubnetListResultPage(cur SubnetListResult, getNextPage func(context.Context, SubnetListResult) (SubnetListResult, error)) SubnetListResultPage {
+ return SubnetListResultPage{
+ fn: getNextPage,
+ slr: cur,
+ }
+}
+
+// SubnetPropertiesFormat properties of the subnet.
+type SubnetPropertiesFormat struct {
+ // AddressPrefix - The address prefix for the subnet.
+ AddressPrefix *string `json:"addressPrefix,omitempty"`
+ // NetworkSecurityGroup - The reference of the NetworkSecurityGroup resource.
+ NetworkSecurityGroup *SecurityGroup `json:"networkSecurityGroup,omitempty"`
+ // RouteTable - The reference of the RouteTable resource.
+ RouteTable *RouteTable `json:"routeTable,omitempty"`
+ // ServiceEndpoints - An array of service endpoints.
+ ServiceEndpoints *[]ServiceEndpointPropertiesFormat `json:"serviceEndpoints,omitempty"`
+ // IPConfigurations - READ-ONLY; Gets an array of references to the network interface IP configurations using subnet.
+ IPConfigurations *[]IPConfiguration `json:"ipConfigurations,omitempty"`
+ // ResourceNavigationLinks - Gets an array of references to the external resources using subnet.
+ ResourceNavigationLinks *[]ResourceNavigationLink `json:"resourceNavigationLinks,omitempty"`
+ // ProvisioningState - The provisioning state of the resource.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for SubnetPropertiesFormat.
+func (spf SubnetPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if spf.AddressPrefix != nil {
+ objectMap["addressPrefix"] = spf.AddressPrefix
+ }
+ if spf.NetworkSecurityGroup != nil {
+ objectMap["networkSecurityGroup"] = spf.NetworkSecurityGroup
+ }
+ if spf.RouteTable != nil {
+ objectMap["routeTable"] = spf.RouteTable
+ }
+ if spf.ServiceEndpoints != nil {
+ objectMap["serviceEndpoints"] = spf.ServiceEndpoints
+ }
+ if spf.ResourceNavigationLinks != nil {
+ objectMap["resourceNavigationLinks"] = spf.ResourceNavigationLinks
+ }
+ if spf.ProvisioningState != nil {
+ objectMap["provisioningState"] = spf.ProvisioningState
+ }
+ return json.Marshal(objectMap)
+}
+
+// SubnetsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SubnetsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SubnetsClient) (Subnet, error)
+}
+
+// SubnetsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type SubnetsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(SubnetsClient) (autorest.Response, error)
+}
+
+// SubResource reference to another subresource.
+type SubResource struct {
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// TagsObject tags object for patch operations.
+type TagsObject struct {
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for TagsObject.
+func (toVar TagsObject) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if toVar.Tags != nil {
+ objectMap["tags"] = toVar.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// Topology topology of the specified resource group.
+type Topology struct {
+ autorest.Response `json:"-"`
+ // ID - READ-ONLY; GUID representing the operation id.
+ ID *string `json:"id,omitempty"`
+ // CreatedDateTime - READ-ONLY; The datetime when the topology was initially created for the resource group.
+ CreatedDateTime *date.Time `json:"createdDateTime,omitempty"`
+ // LastModified - READ-ONLY; The datetime when the topology was last modified.
+ LastModified *date.Time `json:"lastModified,omitempty"`
+ Resources *[]TopologyResource `json:"resources,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Topology.
+func (t Topology) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if t.Resources != nil {
+ objectMap["resources"] = t.Resources
+ }
+ return json.Marshal(objectMap)
+}
+
+// TopologyAssociation resources that have an association with the parent resource.
+type TopologyAssociation struct {
+ // Name - The name of the resource that is associated with the parent resource.
+ Name *string `json:"name,omitempty"`
+ // ResourceID - The ID of the resource that is associated with the parent resource.
+ ResourceID *string `json:"resourceId,omitempty"`
+ // AssociationType - The association type of the child resource to the parent resource. Possible values include: 'Associated', 'Contains'
+ AssociationType AssociationType `json:"associationType,omitempty"`
+}
+
+// TopologyParameters parameters that define the representation of topology.
+type TopologyParameters struct {
+ // TargetResourceGroupName - The name of the target resource group to perform topology on.
+ TargetResourceGroupName *string `json:"targetResourceGroupName,omitempty"`
+ // TargetVirtualNetwork - The reference of the Virtual Network resource.
+ TargetVirtualNetwork *SubResource `json:"targetVirtualNetwork,omitempty"`
+ // TargetSubnet - The reference of the Subnet resource.
+ TargetSubnet *SubResource `json:"targetSubnet,omitempty"`
+}
+
+// TopologyResource the network resource topology information for the given resource group.
+type TopologyResource struct {
+ // Name - Name of the resource.
+ Name *string `json:"name,omitempty"`
+ // ID - ID of the resource.
+ ID *string `json:"id,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Associations - Holds the associations the resource has with other resources in the resource group.
+ Associations *[]TopologyAssociation `json:"associations,omitempty"`
+}
+
+// TroubleshootingDetails information gained from troubleshooting of specified resource.
+type TroubleshootingDetails struct {
+ // ID - The id of the get troubleshoot operation.
+ ID *string `json:"id,omitempty"`
+ // ReasonType - Reason type of failure.
+ ReasonType *string `json:"reasonType,omitempty"`
+ // Summary - A summary of troubleshooting.
+ Summary *string `json:"summary,omitempty"`
+ // Detail - Details on troubleshooting results.
+ Detail *string `json:"detail,omitempty"`
+ // RecommendedActions - List of recommended actions.
+ RecommendedActions *[]TroubleshootingRecommendedActions `json:"recommendedActions,omitempty"`
+}
+
+// TroubleshootingParameters parameters that define the resource to troubleshoot.
+type TroubleshootingParameters struct {
+ // TargetResourceID - The target resource to troubleshoot.
+ TargetResourceID *string `json:"targetResourceId,omitempty"`
+ *TroubleshootingProperties `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for TroubleshootingParameters.
+func (tp TroubleshootingParameters) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if tp.TargetResourceID != nil {
+ objectMap["targetResourceId"] = tp.TargetResourceID
+ }
+ if tp.TroubleshootingProperties != nil {
+ objectMap["properties"] = tp.TroubleshootingProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for TroubleshootingParameters struct.
+func (tp *TroubleshootingParameters) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "targetResourceId":
+ if v != nil {
+ var targetResourceID string
+ err = json.Unmarshal(*v, &targetResourceID)
+ if err != nil {
+ return err
+ }
+ tp.TargetResourceID = &targetResourceID
+ }
+ case "properties":
+ if v != nil {
+ var troubleshootingProperties TroubleshootingProperties
+ err = json.Unmarshal(*v, &troubleshootingProperties)
+ if err != nil {
+ return err
+ }
+ tp.TroubleshootingProperties = &troubleshootingProperties
+ }
+ }
+ }
+
+ return nil
+}
+
+// TroubleshootingProperties storage location provided for troubleshoot.
+type TroubleshootingProperties struct {
+ // StorageID - The ID for the storage account to save the troubleshoot result.
+ StorageID *string `json:"storageId,omitempty"`
+ // StoragePath - The path to the blob to save the troubleshoot result in.
+ StoragePath *string `json:"storagePath,omitempty"`
+}
+
+// TroubleshootingRecommendedActions recommended actions based on discovered issues.
+type TroubleshootingRecommendedActions struct {
+ // ActionID - ID of the recommended action.
+ ActionID *string `json:"actionId,omitempty"`
+ // ActionText - Description of recommended actions.
+ ActionText *string `json:"actionText,omitempty"`
+ // ActionURI - The uri linking to a documentation for the recommended troubleshooting actions.
+ ActionURI *string `json:"actionUri,omitempty"`
+ // ActionURIText - The information from the URI for the recommended troubleshooting actions.
+ ActionURIText *string `json:"actionUriText,omitempty"`
+}
+
+// TroubleshootingResult troubleshooting information gained from specified resource.
+type TroubleshootingResult struct {
+ autorest.Response `json:"-"`
+ // StartTime - The start time of the troubleshooting.
+ StartTime *date.Time `json:"startTime,omitempty"`
+ // EndTime - The end time of the troubleshooting.
+ EndTime *date.Time `json:"endTime,omitempty"`
+ // Code - The result code of the troubleshooting.
+ Code *string `json:"code,omitempty"`
+ // Results - Information from troubleshooting.
+ Results *[]TroubleshootingDetails `json:"results,omitempty"`
+}
+
+// TunnelConnectionHealth virtualNetworkGatewayConnection properties
+type TunnelConnectionHealth struct {
+ // Tunnel - READ-ONLY; Tunnel name.
+ Tunnel *string `json:"tunnel,omitempty"`
+ // ConnectionStatus - READ-ONLY; Virtual network Gateway connection status. Possible values include: 'VirtualNetworkGatewayConnectionStatusUnknown', 'VirtualNetworkGatewayConnectionStatusConnecting', 'VirtualNetworkGatewayConnectionStatusConnected', 'VirtualNetworkGatewayConnectionStatusNotConnected'
+ ConnectionStatus VirtualNetworkGatewayConnectionStatus `json:"connectionStatus,omitempty"`
+ // IngressBytesTransferred - READ-ONLY; The Ingress Bytes Transferred in this connection
+ IngressBytesTransferred *int64 `json:"ingressBytesTransferred,omitempty"`
+ // EgressBytesTransferred - READ-ONLY; The Egress Bytes Transferred in this connection
+ EgressBytesTransferred *int64 `json:"egressBytesTransferred,omitempty"`
+ // LastConnectionEstablishedUtcTime - READ-ONLY; The time at which connection was established in Utc format.
+ LastConnectionEstablishedUtcTime *string `json:"lastConnectionEstablishedUtcTime,omitempty"`
+}
+
+// Usage describes network resource usage.
+type Usage struct {
+ // ID - READ-ONLY; Resource identifier.
+ ID *string `json:"id,omitempty"`
+ // Unit - An enum describing the unit of measurement.
+ Unit *string `json:"unit,omitempty"`
+ // CurrentValue - The current value of the usage.
+ CurrentValue *int64 `json:"currentValue,omitempty"`
+ // Limit - The limit of usage.
+ Limit *int64 `json:"limit,omitempty"`
+ // Name - The name of the type of usage.
+ Name *UsageName `json:"name,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Usage.
+func (u Usage) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if u.Unit != nil {
+ objectMap["unit"] = u.Unit
+ }
+ if u.CurrentValue != nil {
+ objectMap["currentValue"] = u.CurrentValue
+ }
+ if u.Limit != nil {
+ objectMap["limit"] = u.Limit
+ }
+ if u.Name != nil {
+ objectMap["name"] = u.Name
+ }
+ return json.Marshal(objectMap)
+}
+
+// UsageName the usage names.
+type UsageName struct {
+ // Value - A string describing the resource name.
+ Value *string `json:"value,omitempty"`
+ // LocalizedValue - A localized string describing the resource name.
+ LocalizedValue *string `json:"localizedValue,omitempty"`
+}
+
+// UsagesListResult the list usages operation response.
+type UsagesListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The list network resource usages.
+ Value *[]Usage `json:"value,omitempty"`
+ // NextLink - URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// UsagesListResultIterator provides access to a complete listing of Usage values.
+type UsagesListResultIterator struct {
+ i int
+ page UsagesListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *UsagesListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/UsagesListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *UsagesListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter UsagesListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter UsagesListResultIterator) Response() UsagesListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter UsagesListResultIterator) Value() Usage {
+ if !iter.page.NotDone() {
+ return Usage{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the UsagesListResultIterator type.
+func NewUsagesListResultIterator(page UsagesListResultPage) UsagesListResultIterator {
+ return UsagesListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (ulr UsagesListResult) IsEmpty() bool {
+ return ulr.Value == nil || len(*ulr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (ulr UsagesListResult) hasNextLink() bool {
+ return ulr.NextLink != nil && len(*ulr.NextLink) != 0
+}
+
+// usagesListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (ulr UsagesListResult) usagesListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !ulr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(ulr.NextLink)))
+}
+
+// UsagesListResultPage contains a page of Usage values.
+type UsagesListResultPage struct {
+ fn func(context.Context, UsagesListResult) (UsagesListResult, error)
+ ulr UsagesListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *UsagesListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/UsagesListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.ulr)
+ if err != nil {
+ return err
+ }
+ page.ulr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *UsagesListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page UsagesListResultPage) NotDone() bool {
+ return !page.ulr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page UsagesListResultPage) Response() UsagesListResult {
+ return page.ulr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page UsagesListResultPage) Values() []Usage {
+ if page.ulr.IsEmpty() {
+ return nil
+ }
+ return *page.ulr.Value
+}
+
+// Creates a new instance of the UsagesListResultPage type.
+func NewUsagesListResultPage(cur UsagesListResult, getNextPage func(context.Context, UsagesListResult) (UsagesListResult, error)) UsagesListResultPage {
+ return UsagesListResultPage{
+ fn: getNextPage,
+ ulr: cur,
+ }
+}
+
+// VerificationIPFlowParameters parameters that define the IP flow to be verified.
+type VerificationIPFlowParameters struct {
+ // TargetResourceID - The ID of the target resource to perform next-hop on.
+ TargetResourceID *string `json:"targetResourceId,omitempty"`
+ // Direction - The direction of the packet represented as a 5-tuple. Possible values include: 'Inbound', 'Outbound'
+ Direction Direction `json:"direction,omitempty"`
+ // Protocol - Protocol to be verified on. Possible values include: 'ProtocolTCP', 'ProtocolUDP'
+ Protocol Protocol `json:"protocol,omitempty"`
+ // LocalPort - The local port. Acceptable values are a single integer in the range (0-65535). Support for * for the source port, which depends on the direction.
+ LocalPort *string `json:"localPort,omitempty"`
+ // RemotePort - The remote port. Acceptable values are a single integer in the range (0-65535). Support for * for the source port, which depends on the direction.
+ RemotePort *string `json:"remotePort,omitempty"`
+ // LocalIPAddress - The local IP address. Acceptable values are valid IPv4 addresses.
+ LocalIPAddress *string `json:"localIPAddress,omitempty"`
+ // RemoteIPAddress - The remote IP address. Acceptable values are valid IPv4 addresses.
+ RemoteIPAddress *string `json:"remoteIPAddress,omitempty"`
+ // TargetNicResourceID - The NIC ID. (If VM has multiple NICs and IP forwarding is enabled on any of them, then this parameter must be specified. Otherwise optional).
+ TargetNicResourceID *string `json:"targetNicResourceId,omitempty"`
+}
+
+// VerificationIPFlowResult results of IP flow verification on the target resource.
+type VerificationIPFlowResult struct {
+ autorest.Response `json:"-"`
+ // Access - Indicates whether the traffic is allowed or denied. Possible values include: 'Allow', 'Deny'
+ Access Access `json:"access,omitempty"`
+ // RuleName - Name of the rule. If input is not matched against any security rule, it is not displayed.
+ RuleName *string `json:"ruleName,omitempty"`
+}
+
+// VirtualNetwork virtual Network resource.
+type VirtualNetwork struct {
+ autorest.Response `json:"-"`
+ // VirtualNetworkPropertiesFormat - Properties of the virtual network.
+ *VirtualNetworkPropertiesFormat `json:"properties,omitempty"`
+ // Etag - Gets a unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetwork.
+func (vn VirtualNetwork) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vn.VirtualNetworkPropertiesFormat != nil {
+ objectMap["properties"] = vn.VirtualNetworkPropertiesFormat
+ }
+ if vn.Etag != nil {
+ objectMap["etag"] = vn.Etag
+ }
+ if vn.ID != nil {
+ objectMap["id"] = vn.ID
+ }
+ if vn.Location != nil {
+ objectMap["location"] = vn.Location
+ }
+ if vn.Tags != nil {
+ objectMap["tags"] = vn.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualNetwork struct.
+func (vn *VirtualNetwork) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualNetworkPropertiesFormat VirtualNetworkPropertiesFormat
+ err = json.Unmarshal(*v, &virtualNetworkPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vn.VirtualNetworkPropertiesFormat = &virtualNetworkPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vn.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vn.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vn.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vn.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vn.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vn.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualNetworkConnectionGatewayReference a reference to VirtualNetworkGateway or LocalNetworkGateway
+// resource.
+type VirtualNetworkConnectionGatewayReference struct {
+ // ID - The ID of VirtualNetworkGateway or LocalNetworkGateway resource.
+ ID *string `json:"id,omitempty"`
+}
+
+// VirtualNetworkGateway a common class for general resource information
+type VirtualNetworkGateway struct {
+ autorest.Response `json:"-"`
+ // VirtualNetworkGatewayPropertiesFormat - Properties of the virtual network gateway.
+ *VirtualNetworkGatewayPropertiesFormat `json:"properties,omitempty"`
+ // Etag - Gets a unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGateway.
+func (vng VirtualNetworkGateway) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vng.VirtualNetworkGatewayPropertiesFormat != nil {
+ objectMap["properties"] = vng.VirtualNetworkGatewayPropertiesFormat
+ }
+ if vng.Etag != nil {
+ objectMap["etag"] = vng.Etag
+ }
+ if vng.ID != nil {
+ objectMap["id"] = vng.ID
+ }
+ if vng.Location != nil {
+ objectMap["location"] = vng.Location
+ }
+ if vng.Tags != nil {
+ objectMap["tags"] = vng.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualNetworkGateway struct.
+func (vng *VirtualNetworkGateway) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualNetworkGatewayPropertiesFormat VirtualNetworkGatewayPropertiesFormat
+ err = json.Unmarshal(*v, &virtualNetworkGatewayPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vng.VirtualNetworkGatewayPropertiesFormat = &virtualNetworkGatewayPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vng.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vng.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vng.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vng.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vng.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vng.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualNetworkGatewayConnection a common class for general resource information
+type VirtualNetworkGatewayConnection struct {
+ autorest.Response `json:"-"`
+ // VirtualNetworkGatewayConnectionPropertiesFormat - Properties of the virtual network gateway connection.
+ *VirtualNetworkGatewayConnectionPropertiesFormat `json:"properties,omitempty"`
+ // Etag - Gets a unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayConnection.
+func (vngc VirtualNetworkGatewayConnection) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngc.VirtualNetworkGatewayConnectionPropertiesFormat != nil {
+ objectMap["properties"] = vngc.VirtualNetworkGatewayConnectionPropertiesFormat
+ }
+ if vngc.Etag != nil {
+ objectMap["etag"] = vngc.Etag
+ }
+ if vngc.ID != nil {
+ objectMap["id"] = vngc.ID
+ }
+ if vngc.Location != nil {
+ objectMap["location"] = vngc.Location
+ }
+ if vngc.Tags != nil {
+ objectMap["tags"] = vngc.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualNetworkGatewayConnection struct.
+func (vngc *VirtualNetworkGatewayConnection) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualNetworkGatewayConnectionPropertiesFormat VirtualNetworkGatewayConnectionPropertiesFormat
+ err = json.Unmarshal(*v, &virtualNetworkGatewayConnectionPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vngc.VirtualNetworkGatewayConnectionPropertiesFormat = &virtualNetworkGatewayConnectionPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vngc.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vngc.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vngc.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vngc.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vngc.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vngc.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualNetworkGatewayConnectionListEntity a common class for general resource information
+type VirtualNetworkGatewayConnectionListEntity struct {
+ autorest.Response `json:"-"`
+ // VirtualNetworkGatewayConnectionListEntityPropertiesFormat - Properties of the virtual network gateway connection.
+ *VirtualNetworkGatewayConnectionListEntityPropertiesFormat `json:"properties,omitempty"`
+ // Etag - Gets a unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayConnectionListEntity.
+func (vngcle VirtualNetworkGatewayConnectionListEntity) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngcle.VirtualNetworkGatewayConnectionListEntityPropertiesFormat != nil {
+ objectMap["properties"] = vngcle.VirtualNetworkGatewayConnectionListEntityPropertiesFormat
+ }
+ if vngcle.Etag != nil {
+ objectMap["etag"] = vngcle.Etag
+ }
+ if vngcle.ID != nil {
+ objectMap["id"] = vngcle.ID
+ }
+ if vngcle.Location != nil {
+ objectMap["location"] = vngcle.Location
+ }
+ if vngcle.Tags != nil {
+ objectMap["tags"] = vngcle.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualNetworkGatewayConnectionListEntity struct.
+func (vngcle *VirtualNetworkGatewayConnectionListEntity) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualNetworkGatewayConnectionListEntityPropertiesFormat VirtualNetworkGatewayConnectionListEntityPropertiesFormat
+ err = json.Unmarshal(*v, &virtualNetworkGatewayConnectionListEntityPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vngcle.VirtualNetworkGatewayConnectionListEntityPropertiesFormat = &virtualNetworkGatewayConnectionListEntityPropertiesFormat
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vngcle.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vngcle.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vngcle.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ vngcle.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ vngcle.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ vngcle.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualNetworkGatewayConnectionListEntityPropertiesFormat virtualNetworkGatewayConnection properties
+type VirtualNetworkGatewayConnectionListEntityPropertiesFormat struct {
+ // AuthorizationKey - The authorizationKey.
+ AuthorizationKey *string `json:"authorizationKey,omitempty"`
+ // VirtualNetworkGateway1 - The reference to virtual network gateway resource.
+ VirtualNetworkGateway1 *VirtualNetworkConnectionGatewayReference `json:"virtualNetworkGateway1,omitempty"`
+ // VirtualNetworkGateway2 - The reference to virtual network gateway resource.
+ VirtualNetworkGateway2 *VirtualNetworkConnectionGatewayReference `json:"virtualNetworkGateway2,omitempty"`
+ // LocalNetworkGateway2 - The reference to local network gateway resource.
+ LocalNetworkGateway2 *VirtualNetworkConnectionGatewayReference `json:"localNetworkGateway2,omitempty"`
+ // ConnectionType - Gateway connection type. Possible values are: 'IPsec','Vnet2Vnet','ExpressRoute', and 'VPNClient. Possible values include: 'IPsec', 'Vnet2Vnet', 'ExpressRoute', 'VPNClient'
+ ConnectionType VirtualNetworkGatewayConnectionType `json:"connectionType,omitempty"`
+ // RoutingWeight - The routing weight.
+ RoutingWeight *int32 `json:"routingWeight,omitempty"`
+ // SharedKey - The IPSec shared key.
+ SharedKey *string `json:"sharedKey,omitempty"`
+ // ConnectionStatus - READ-ONLY; Virtual network Gateway connection status. Possible values are 'Unknown', 'Connecting', 'Connected' and 'NotConnected'. Possible values include: 'VirtualNetworkGatewayConnectionStatusUnknown', 'VirtualNetworkGatewayConnectionStatusConnecting', 'VirtualNetworkGatewayConnectionStatusConnected', 'VirtualNetworkGatewayConnectionStatusNotConnected'
+ ConnectionStatus VirtualNetworkGatewayConnectionStatus `json:"connectionStatus,omitempty"`
+ // TunnelConnectionStatus - READ-ONLY; Collection of all tunnels' connection health status.
+ TunnelConnectionStatus *[]TunnelConnectionHealth `json:"tunnelConnectionStatus,omitempty"`
+ // EgressBytesTransferred - READ-ONLY; The egress bytes transferred in this connection.
+ EgressBytesTransferred *int64 `json:"egressBytesTransferred,omitempty"`
+ // IngressBytesTransferred - READ-ONLY; The ingress bytes transferred in this connection.
+ IngressBytesTransferred *int64 `json:"ingressBytesTransferred,omitempty"`
+ // Peer - The reference to peerings resource.
+ Peer *SubResource `json:"peer,omitempty"`
+ // EnableBgp - EnableBgp flag
+ EnableBgp *bool `json:"enableBgp,omitempty"`
+ // UsePolicyBasedTrafficSelectors - Enable policy-based traffic selectors.
+ UsePolicyBasedTrafficSelectors *bool `json:"usePolicyBasedTrafficSelectors,omitempty"`
+ // IpsecPolicies - The IPSec Policies to be considered by this connection.
+ IpsecPolicies *[]IpsecPolicy `json:"ipsecPolicies,omitempty"`
+ // ResourceGUID - The resource GUID property of the VirtualNetworkGatewayConnection resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the VirtualNetworkGatewayConnection resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayConnectionListEntityPropertiesFormat.
+func (vngclepf VirtualNetworkGatewayConnectionListEntityPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngclepf.AuthorizationKey != nil {
+ objectMap["authorizationKey"] = vngclepf.AuthorizationKey
+ }
+ if vngclepf.VirtualNetworkGateway1 != nil {
+ objectMap["virtualNetworkGateway1"] = vngclepf.VirtualNetworkGateway1
+ }
+ if vngclepf.VirtualNetworkGateway2 != nil {
+ objectMap["virtualNetworkGateway2"] = vngclepf.VirtualNetworkGateway2
+ }
+ if vngclepf.LocalNetworkGateway2 != nil {
+ objectMap["localNetworkGateway2"] = vngclepf.LocalNetworkGateway2
+ }
+ if vngclepf.ConnectionType != "" {
+ objectMap["connectionType"] = vngclepf.ConnectionType
+ }
+ if vngclepf.RoutingWeight != nil {
+ objectMap["routingWeight"] = vngclepf.RoutingWeight
+ }
+ if vngclepf.SharedKey != nil {
+ objectMap["sharedKey"] = vngclepf.SharedKey
+ }
+ if vngclepf.Peer != nil {
+ objectMap["peer"] = vngclepf.Peer
+ }
+ if vngclepf.EnableBgp != nil {
+ objectMap["enableBgp"] = vngclepf.EnableBgp
+ }
+ if vngclepf.UsePolicyBasedTrafficSelectors != nil {
+ objectMap["usePolicyBasedTrafficSelectors"] = vngclepf.UsePolicyBasedTrafficSelectors
+ }
+ if vngclepf.IpsecPolicies != nil {
+ objectMap["ipsecPolicies"] = vngclepf.IpsecPolicies
+ }
+ if vngclepf.ResourceGUID != nil {
+ objectMap["resourceGuid"] = vngclepf.ResourceGUID
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkGatewayConnectionListResult response for the ListVirtualNetworkGatewayConnections API
+// service call
+type VirtualNetworkGatewayConnectionListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of VirtualNetworkGatewayConnection resources that exists in a resource group.
+ Value *[]VirtualNetworkGatewayConnection `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayConnectionListResult.
+func (vngclr VirtualNetworkGatewayConnectionListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngclr.Value != nil {
+ objectMap["value"] = vngclr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkGatewayConnectionListResultIterator provides access to a complete listing of
+// VirtualNetworkGatewayConnection values.
+type VirtualNetworkGatewayConnectionListResultIterator struct {
+ i int
+ page VirtualNetworkGatewayConnectionListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualNetworkGatewayConnectionListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualNetworkGatewayConnectionListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualNetworkGatewayConnectionListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualNetworkGatewayConnectionListResultIterator) Response() VirtualNetworkGatewayConnectionListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualNetworkGatewayConnectionListResultIterator) Value() VirtualNetworkGatewayConnection {
+ if !iter.page.NotDone() {
+ return VirtualNetworkGatewayConnection{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualNetworkGatewayConnectionListResultIterator type.
+func NewVirtualNetworkGatewayConnectionListResultIterator(page VirtualNetworkGatewayConnectionListResultPage) VirtualNetworkGatewayConnectionListResultIterator {
+ return VirtualNetworkGatewayConnectionListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vngclr VirtualNetworkGatewayConnectionListResult) IsEmpty() bool {
+ return vngclr.Value == nil || len(*vngclr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vngclr VirtualNetworkGatewayConnectionListResult) hasNextLink() bool {
+ return vngclr.NextLink != nil && len(*vngclr.NextLink) != 0
+}
+
+// virtualNetworkGatewayConnectionListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vngclr VirtualNetworkGatewayConnectionListResult) virtualNetworkGatewayConnectionListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vngclr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vngclr.NextLink)))
+}
+
+// VirtualNetworkGatewayConnectionListResultPage contains a page of VirtualNetworkGatewayConnection values.
+type VirtualNetworkGatewayConnectionListResultPage struct {
+ fn func(context.Context, VirtualNetworkGatewayConnectionListResult) (VirtualNetworkGatewayConnectionListResult, error)
+ vngclr VirtualNetworkGatewayConnectionListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualNetworkGatewayConnectionListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vngclr)
+ if err != nil {
+ return err
+ }
+ page.vngclr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualNetworkGatewayConnectionListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualNetworkGatewayConnectionListResultPage) NotDone() bool {
+ return !page.vngclr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualNetworkGatewayConnectionListResultPage) Response() VirtualNetworkGatewayConnectionListResult {
+ return page.vngclr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualNetworkGatewayConnectionListResultPage) Values() []VirtualNetworkGatewayConnection {
+ if page.vngclr.IsEmpty() {
+ return nil
+ }
+ return *page.vngclr.Value
+}
+
+// Creates a new instance of the VirtualNetworkGatewayConnectionListResultPage type.
+func NewVirtualNetworkGatewayConnectionListResultPage(cur VirtualNetworkGatewayConnectionListResult, getNextPage func(context.Context, VirtualNetworkGatewayConnectionListResult) (VirtualNetworkGatewayConnectionListResult, error)) VirtualNetworkGatewayConnectionListResultPage {
+ return VirtualNetworkGatewayConnectionListResultPage{
+ fn: getNextPage,
+ vngclr: cur,
+ }
+}
+
+// VirtualNetworkGatewayConnectionPropertiesFormat virtualNetworkGatewayConnection properties
+type VirtualNetworkGatewayConnectionPropertiesFormat struct {
+ // AuthorizationKey - The authorizationKey.
+ AuthorizationKey *string `json:"authorizationKey,omitempty"`
+ // VirtualNetworkGateway1 - The reference to virtual network gateway resource.
+ VirtualNetworkGateway1 *VirtualNetworkGateway `json:"virtualNetworkGateway1,omitempty"`
+ // VirtualNetworkGateway2 - The reference to virtual network gateway resource.
+ VirtualNetworkGateway2 *VirtualNetworkGateway `json:"virtualNetworkGateway2,omitempty"`
+ // LocalNetworkGateway2 - The reference to local network gateway resource.
+ LocalNetworkGateway2 *LocalNetworkGateway `json:"localNetworkGateway2,omitempty"`
+ // ConnectionType - Gateway connection type. Possible values are: 'IPsec','Vnet2Vnet','ExpressRoute', and 'VPNClient. Possible values include: 'IPsec', 'Vnet2Vnet', 'ExpressRoute', 'VPNClient'
+ ConnectionType VirtualNetworkGatewayConnectionType `json:"connectionType,omitempty"`
+ // RoutingWeight - The routing weight.
+ RoutingWeight *int32 `json:"routingWeight,omitempty"`
+ // SharedKey - The IPSec shared key.
+ SharedKey *string `json:"sharedKey,omitempty"`
+ // ConnectionStatus - READ-ONLY; Virtual network Gateway connection status. Possible values are 'Unknown', 'Connecting', 'Connected' and 'NotConnected'. Possible values include: 'VirtualNetworkGatewayConnectionStatusUnknown', 'VirtualNetworkGatewayConnectionStatusConnecting', 'VirtualNetworkGatewayConnectionStatusConnected', 'VirtualNetworkGatewayConnectionStatusNotConnected'
+ ConnectionStatus VirtualNetworkGatewayConnectionStatus `json:"connectionStatus,omitempty"`
+ // TunnelConnectionStatus - READ-ONLY; Collection of all tunnels' connection health status.
+ TunnelConnectionStatus *[]TunnelConnectionHealth `json:"tunnelConnectionStatus,omitempty"`
+ // EgressBytesTransferred - READ-ONLY; The egress bytes transferred in this connection.
+ EgressBytesTransferred *int64 `json:"egressBytesTransferred,omitempty"`
+ // IngressBytesTransferred - READ-ONLY; The ingress bytes transferred in this connection.
+ IngressBytesTransferred *int64 `json:"ingressBytesTransferred,omitempty"`
+ // Peer - The reference to peerings resource.
+ Peer *SubResource `json:"peer,omitempty"`
+ // EnableBgp - EnableBgp flag
+ EnableBgp *bool `json:"enableBgp,omitempty"`
+ // UsePolicyBasedTrafficSelectors - Enable policy-based traffic selectors.
+ UsePolicyBasedTrafficSelectors *bool `json:"usePolicyBasedTrafficSelectors,omitempty"`
+ // IpsecPolicies - The IPSec Policies to be considered by this connection.
+ IpsecPolicies *[]IpsecPolicy `json:"ipsecPolicies,omitempty"`
+ // ResourceGUID - The resource GUID property of the VirtualNetworkGatewayConnection resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the VirtualNetworkGatewayConnection resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayConnectionPropertiesFormat.
+func (vngcpf VirtualNetworkGatewayConnectionPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngcpf.AuthorizationKey != nil {
+ objectMap["authorizationKey"] = vngcpf.AuthorizationKey
+ }
+ if vngcpf.VirtualNetworkGateway1 != nil {
+ objectMap["virtualNetworkGateway1"] = vngcpf.VirtualNetworkGateway1
+ }
+ if vngcpf.VirtualNetworkGateway2 != nil {
+ objectMap["virtualNetworkGateway2"] = vngcpf.VirtualNetworkGateway2
+ }
+ if vngcpf.LocalNetworkGateway2 != nil {
+ objectMap["localNetworkGateway2"] = vngcpf.LocalNetworkGateway2
+ }
+ if vngcpf.ConnectionType != "" {
+ objectMap["connectionType"] = vngcpf.ConnectionType
+ }
+ if vngcpf.RoutingWeight != nil {
+ objectMap["routingWeight"] = vngcpf.RoutingWeight
+ }
+ if vngcpf.SharedKey != nil {
+ objectMap["sharedKey"] = vngcpf.SharedKey
+ }
+ if vngcpf.Peer != nil {
+ objectMap["peer"] = vngcpf.Peer
+ }
+ if vngcpf.EnableBgp != nil {
+ objectMap["enableBgp"] = vngcpf.EnableBgp
+ }
+ if vngcpf.UsePolicyBasedTrafficSelectors != nil {
+ objectMap["usePolicyBasedTrafficSelectors"] = vngcpf.UsePolicyBasedTrafficSelectors
+ }
+ if vngcpf.IpsecPolicies != nil {
+ objectMap["ipsecPolicies"] = vngcpf.IpsecPolicies
+ }
+ if vngcpf.ResourceGUID != nil {
+ objectMap["resourceGuid"] = vngcpf.ResourceGUID
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkGatewayConnectionsCreateOrUpdateFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualNetworkGatewayConnectionsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewayConnectionsClient) (VirtualNetworkGatewayConnection, error)
+}
+
+// VirtualNetworkGatewayConnectionsDeleteFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualNetworkGatewayConnectionsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewayConnectionsClient) (autorest.Response, error)
+}
+
+// VirtualNetworkGatewayConnectionsResetSharedKeyFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualNetworkGatewayConnectionsResetSharedKeyFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewayConnectionsClient) (ConnectionResetSharedKey, error)
+}
+
+// VirtualNetworkGatewayConnectionsSetSharedKeyFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualNetworkGatewayConnectionsSetSharedKeyFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewayConnectionsClient) (ConnectionSharedKey, error)
+}
+
+// VirtualNetworkGatewayConnectionsUpdateTagsFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualNetworkGatewayConnectionsUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewayConnectionsClient) (VirtualNetworkGatewayConnectionListEntity, error)
+}
+
+// VirtualNetworkGatewayIPConfiguration IP configuration for virtual network gateway
+type VirtualNetworkGatewayIPConfiguration struct {
+ // VirtualNetworkGatewayIPConfigurationPropertiesFormat - Properties of the virtual network gateway ip configuration.
+ *VirtualNetworkGatewayIPConfigurationPropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayIPConfiguration.
+func (vngic VirtualNetworkGatewayIPConfiguration) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngic.VirtualNetworkGatewayIPConfigurationPropertiesFormat != nil {
+ objectMap["properties"] = vngic.VirtualNetworkGatewayIPConfigurationPropertiesFormat
+ }
+ if vngic.Name != nil {
+ objectMap["name"] = vngic.Name
+ }
+ if vngic.Etag != nil {
+ objectMap["etag"] = vngic.Etag
+ }
+ if vngic.ID != nil {
+ objectMap["id"] = vngic.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualNetworkGatewayIPConfiguration struct.
+func (vngic *VirtualNetworkGatewayIPConfiguration) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualNetworkGatewayIPConfigurationPropertiesFormat VirtualNetworkGatewayIPConfigurationPropertiesFormat
+ err = json.Unmarshal(*v, &virtualNetworkGatewayIPConfigurationPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vngic.VirtualNetworkGatewayIPConfigurationPropertiesFormat = &virtualNetworkGatewayIPConfigurationPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vngic.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vngic.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vngic.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualNetworkGatewayIPConfigurationPropertiesFormat properties of VirtualNetworkGatewayIPConfiguration
+type VirtualNetworkGatewayIPConfigurationPropertiesFormat struct {
+ // PrivateIPAllocationMethod - The private IP allocation method. Possible values are: 'Static' and 'Dynamic'. Possible values include: 'Static', 'Dynamic'
+ PrivateIPAllocationMethod IPAllocationMethod `json:"privateIPAllocationMethod,omitempty"`
+ // Subnet - The reference of the subnet resource.
+ Subnet *SubResource `json:"subnet,omitempty"`
+ // PublicIPAddress - The reference of the public IP resource.
+ PublicIPAddress *SubResource `json:"publicIPAddress,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayIPConfigurationPropertiesFormat.
+func (vngicpf VirtualNetworkGatewayIPConfigurationPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngicpf.PrivateIPAllocationMethod != "" {
+ objectMap["privateIPAllocationMethod"] = vngicpf.PrivateIPAllocationMethod
+ }
+ if vngicpf.Subnet != nil {
+ objectMap["subnet"] = vngicpf.Subnet
+ }
+ if vngicpf.PublicIPAddress != nil {
+ objectMap["publicIPAddress"] = vngicpf.PublicIPAddress
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkGatewayListConnectionsResult response for the VirtualNetworkGatewayListConnections API
+// service call
+type VirtualNetworkGatewayListConnectionsResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of VirtualNetworkGatewayConnection resources that exists in a resource group.
+ Value *[]VirtualNetworkGatewayConnectionListEntity `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayListConnectionsResult.
+func (vnglcr VirtualNetworkGatewayListConnectionsResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vnglcr.Value != nil {
+ objectMap["value"] = vnglcr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkGatewayListConnectionsResultIterator provides access to a complete listing of
+// VirtualNetworkGatewayConnectionListEntity values.
+type VirtualNetworkGatewayListConnectionsResultIterator struct {
+ i int
+ page VirtualNetworkGatewayListConnectionsResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualNetworkGatewayListConnectionsResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayListConnectionsResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualNetworkGatewayListConnectionsResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualNetworkGatewayListConnectionsResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualNetworkGatewayListConnectionsResultIterator) Response() VirtualNetworkGatewayListConnectionsResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualNetworkGatewayListConnectionsResultIterator) Value() VirtualNetworkGatewayConnectionListEntity {
+ if !iter.page.NotDone() {
+ return VirtualNetworkGatewayConnectionListEntity{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualNetworkGatewayListConnectionsResultIterator type.
+func NewVirtualNetworkGatewayListConnectionsResultIterator(page VirtualNetworkGatewayListConnectionsResultPage) VirtualNetworkGatewayListConnectionsResultIterator {
+ return VirtualNetworkGatewayListConnectionsResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vnglcr VirtualNetworkGatewayListConnectionsResult) IsEmpty() bool {
+ return vnglcr.Value == nil || len(*vnglcr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vnglcr VirtualNetworkGatewayListConnectionsResult) hasNextLink() bool {
+ return vnglcr.NextLink != nil && len(*vnglcr.NextLink) != 0
+}
+
+// virtualNetworkGatewayListConnectionsResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vnglcr VirtualNetworkGatewayListConnectionsResult) virtualNetworkGatewayListConnectionsResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vnglcr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vnglcr.NextLink)))
+}
+
+// VirtualNetworkGatewayListConnectionsResultPage contains a page of
+// VirtualNetworkGatewayConnectionListEntity values.
+type VirtualNetworkGatewayListConnectionsResultPage struct {
+ fn func(context.Context, VirtualNetworkGatewayListConnectionsResult) (VirtualNetworkGatewayListConnectionsResult, error)
+ vnglcr VirtualNetworkGatewayListConnectionsResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualNetworkGatewayListConnectionsResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayListConnectionsResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vnglcr)
+ if err != nil {
+ return err
+ }
+ page.vnglcr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualNetworkGatewayListConnectionsResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualNetworkGatewayListConnectionsResultPage) NotDone() bool {
+ return !page.vnglcr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualNetworkGatewayListConnectionsResultPage) Response() VirtualNetworkGatewayListConnectionsResult {
+ return page.vnglcr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualNetworkGatewayListConnectionsResultPage) Values() []VirtualNetworkGatewayConnectionListEntity {
+ if page.vnglcr.IsEmpty() {
+ return nil
+ }
+ return *page.vnglcr.Value
+}
+
+// Creates a new instance of the VirtualNetworkGatewayListConnectionsResultPage type.
+func NewVirtualNetworkGatewayListConnectionsResultPage(cur VirtualNetworkGatewayListConnectionsResult, getNextPage func(context.Context, VirtualNetworkGatewayListConnectionsResult) (VirtualNetworkGatewayListConnectionsResult, error)) VirtualNetworkGatewayListConnectionsResultPage {
+ return VirtualNetworkGatewayListConnectionsResultPage{
+ fn: getNextPage,
+ vnglcr: cur,
+ }
+}
+
+// VirtualNetworkGatewayListResult response for the ListVirtualNetworkGateways API service call.
+type VirtualNetworkGatewayListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of VirtualNetworkGateway resources that exists in a resource group.
+ Value *[]VirtualNetworkGateway `json:"value,omitempty"`
+ // NextLink - READ-ONLY; The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayListResult.
+func (vnglr VirtualNetworkGatewayListResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vnglr.Value != nil {
+ objectMap["value"] = vnglr.Value
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkGatewayListResultIterator provides access to a complete listing of VirtualNetworkGateway
+// values.
+type VirtualNetworkGatewayListResultIterator struct {
+ i int
+ page VirtualNetworkGatewayListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualNetworkGatewayListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualNetworkGatewayListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualNetworkGatewayListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualNetworkGatewayListResultIterator) Response() VirtualNetworkGatewayListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualNetworkGatewayListResultIterator) Value() VirtualNetworkGateway {
+ if !iter.page.NotDone() {
+ return VirtualNetworkGateway{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualNetworkGatewayListResultIterator type.
+func NewVirtualNetworkGatewayListResultIterator(page VirtualNetworkGatewayListResultPage) VirtualNetworkGatewayListResultIterator {
+ return VirtualNetworkGatewayListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vnglr VirtualNetworkGatewayListResult) IsEmpty() bool {
+ return vnglr.Value == nil || len(*vnglr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vnglr VirtualNetworkGatewayListResult) hasNextLink() bool {
+ return vnglr.NextLink != nil && len(*vnglr.NextLink) != 0
+}
+
+// virtualNetworkGatewayListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vnglr VirtualNetworkGatewayListResult) virtualNetworkGatewayListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vnglr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vnglr.NextLink)))
+}
+
+// VirtualNetworkGatewayListResultPage contains a page of VirtualNetworkGateway values.
+type VirtualNetworkGatewayListResultPage struct {
+ fn func(context.Context, VirtualNetworkGatewayListResult) (VirtualNetworkGatewayListResult, error)
+ vnglr VirtualNetworkGatewayListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualNetworkGatewayListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vnglr)
+ if err != nil {
+ return err
+ }
+ page.vnglr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualNetworkGatewayListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualNetworkGatewayListResultPage) NotDone() bool {
+ return !page.vnglr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualNetworkGatewayListResultPage) Response() VirtualNetworkGatewayListResult {
+ return page.vnglr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualNetworkGatewayListResultPage) Values() []VirtualNetworkGateway {
+ if page.vnglr.IsEmpty() {
+ return nil
+ }
+ return *page.vnglr.Value
+}
+
+// Creates a new instance of the VirtualNetworkGatewayListResultPage type.
+func NewVirtualNetworkGatewayListResultPage(cur VirtualNetworkGatewayListResult, getNextPage func(context.Context, VirtualNetworkGatewayListResult) (VirtualNetworkGatewayListResult, error)) VirtualNetworkGatewayListResultPage {
+ return VirtualNetworkGatewayListResultPage{
+ fn: getNextPage,
+ vnglr: cur,
+ }
+}
+
+// VirtualNetworkGatewayPropertiesFormat virtualNetworkGateway properties
+type VirtualNetworkGatewayPropertiesFormat struct {
+ // IPConfigurations - IP configurations for virtual network gateway.
+ IPConfigurations *[]VirtualNetworkGatewayIPConfiguration `json:"ipConfigurations,omitempty"`
+ // GatewayType - The type of this virtual network gateway. Possible values are: 'Vpn' and 'ExpressRoute'. Possible values include: 'VirtualNetworkGatewayTypeVpn', 'VirtualNetworkGatewayTypeExpressRoute'
+ GatewayType VirtualNetworkGatewayType `json:"gatewayType,omitempty"`
+ // VpnType - The type of this virtual network gateway. Possible values are: 'PolicyBased' and 'RouteBased'. Possible values include: 'PolicyBased', 'RouteBased'
+ VpnType VpnType `json:"vpnType,omitempty"`
+ // EnableBgp - Whether BGP is enabled for this virtual network gateway or not.
+ EnableBgp *bool `json:"enableBgp,omitempty"`
+ // ActiveActive - ActiveActive flag
+ ActiveActive *bool `json:"activeActive,omitempty"`
+ // GatewayDefaultSite - The reference of the LocalNetworkGateway resource which represents local network site having default routes. Assign Null value in case of removing existing default site setting.
+ GatewayDefaultSite *SubResource `json:"gatewayDefaultSite,omitempty"`
+ // Sku - The reference of the VirtualNetworkGatewaySku resource which represents the SKU selected for Virtual network gateway.
+ Sku *VirtualNetworkGatewaySku `json:"sku,omitempty"`
+ // VpnClientConfiguration - The reference of the VpnClientConfiguration resource which represents the P2S VpnClient configurations.
+ VpnClientConfiguration *VpnClientConfiguration `json:"vpnClientConfiguration,omitempty"`
+ // BgpSettings - Virtual network gateway's BGP speaker settings.
+ BgpSettings *BgpSettings `json:"bgpSettings,omitempty"`
+ // ResourceGUID - The resource GUID property of the VirtualNetworkGateway resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the VirtualNetworkGateway resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkGatewayPropertiesFormat.
+func (vngpf VirtualNetworkGatewayPropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vngpf.IPConfigurations != nil {
+ objectMap["ipConfigurations"] = vngpf.IPConfigurations
+ }
+ if vngpf.GatewayType != "" {
+ objectMap["gatewayType"] = vngpf.GatewayType
+ }
+ if vngpf.VpnType != "" {
+ objectMap["vpnType"] = vngpf.VpnType
+ }
+ if vngpf.EnableBgp != nil {
+ objectMap["enableBgp"] = vngpf.EnableBgp
+ }
+ if vngpf.ActiveActive != nil {
+ objectMap["activeActive"] = vngpf.ActiveActive
+ }
+ if vngpf.GatewayDefaultSite != nil {
+ objectMap["gatewayDefaultSite"] = vngpf.GatewayDefaultSite
+ }
+ if vngpf.Sku != nil {
+ objectMap["sku"] = vngpf.Sku
+ }
+ if vngpf.VpnClientConfiguration != nil {
+ objectMap["vpnClientConfiguration"] = vngpf.VpnClientConfiguration
+ }
+ if vngpf.BgpSettings != nil {
+ objectMap["bgpSettings"] = vngpf.BgpSettings
+ }
+ if vngpf.ResourceGUID != nil {
+ objectMap["resourceGuid"] = vngpf.ResourceGUID
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkGatewaysCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworkGatewaysCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (VirtualNetworkGateway, error)
+}
+
+// VirtualNetworkGatewaysDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworkGatewaysDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (autorest.Response, error)
+}
+
+// VirtualNetworkGatewaysGeneratevpnclientpackageFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualNetworkGatewaysGeneratevpnclientpackageFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (String, error)
+}
+
+// VirtualNetworkGatewaysGenerateVpnProfileFuture an abstraction for monitoring and retrieving the results
+// of a long-running operation.
+type VirtualNetworkGatewaysGenerateVpnProfileFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (String, error)
+}
+
+// VirtualNetworkGatewaysGetAdvertisedRoutesFuture an abstraction for monitoring and retrieving the results
+// of a long-running operation.
+type VirtualNetworkGatewaysGetAdvertisedRoutesFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (GatewayRouteListResult, error)
+}
+
+// VirtualNetworkGatewaysGetBgpPeerStatusFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualNetworkGatewaysGetBgpPeerStatusFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (BgpPeerStatusListResult, error)
+}
+
+// VirtualNetworkGatewaysGetLearnedRoutesFuture an abstraction for monitoring and retrieving the results of
+// a long-running operation.
+type VirtualNetworkGatewaysGetLearnedRoutesFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (GatewayRouteListResult, error)
+}
+
+// VirtualNetworkGatewaysGetVpnProfilePackageURLFuture an abstraction for monitoring and retrieving the
+// results of a long-running operation.
+type VirtualNetworkGatewaysGetVpnProfilePackageURLFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (String, error)
+}
+
+// VirtualNetworkGatewaySku virtualNetworkGatewaySku details
+type VirtualNetworkGatewaySku struct {
+ // Name - Gateway SKU name. Possible values include: 'VirtualNetworkGatewaySkuNameBasic', 'VirtualNetworkGatewaySkuNameHighPerformance', 'VirtualNetworkGatewaySkuNameStandard', 'VirtualNetworkGatewaySkuNameUltraPerformance', 'VirtualNetworkGatewaySkuNameVpnGw1', 'VirtualNetworkGatewaySkuNameVpnGw2', 'VirtualNetworkGatewaySkuNameVpnGw3'
+ Name VirtualNetworkGatewaySkuName `json:"name,omitempty"`
+ // Tier - Gateway SKU tier. Possible values include: 'VirtualNetworkGatewaySkuTierBasic', 'VirtualNetworkGatewaySkuTierHighPerformance', 'VirtualNetworkGatewaySkuTierStandard', 'VirtualNetworkGatewaySkuTierUltraPerformance', 'VirtualNetworkGatewaySkuTierVpnGw1', 'VirtualNetworkGatewaySkuTierVpnGw2', 'VirtualNetworkGatewaySkuTierVpnGw3'
+ Tier VirtualNetworkGatewaySkuTier `json:"tier,omitempty"`
+ // Capacity - The capacity.
+ Capacity *int32 `json:"capacity,omitempty"`
+}
+
+// VirtualNetworkGatewaysResetFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworkGatewaysResetFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (VirtualNetworkGateway, error)
+}
+
+// VirtualNetworkGatewaysUpdateTagsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworkGatewaysUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkGatewaysClient) (VirtualNetworkGateway, error)
+}
+
+// VirtualNetworkListResult response for the ListVirtualNetworks API service call.
+type VirtualNetworkListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets a list of VirtualNetwork resources in a resource group.
+ Value *[]VirtualNetwork `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualNetworkListResultIterator provides access to a complete listing of VirtualNetwork values.
+type VirtualNetworkListResultIterator struct {
+ i int
+ page VirtualNetworkListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualNetworkListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualNetworkListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualNetworkListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualNetworkListResultIterator) Response() VirtualNetworkListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualNetworkListResultIterator) Value() VirtualNetwork {
+ if !iter.page.NotDone() {
+ return VirtualNetwork{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualNetworkListResultIterator type.
+func NewVirtualNetworkListResultIterator(page VirtualNetworkListResultPage) VirtualNetworkListResultIterator {
+ return VirtualNetworkListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vnlr VirtualNetworkListResult) IsEmpty() bool {
+ return vnlr.Value == nil || len(*vnlr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vnlr VirtualNetworkListResult) hasNextLink() bool {
+ return vnlr.NextLink != nil && len(*vnlr.NextLink) != 0
+}
+
+// virtualNetworkListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vnlr VirtualNetworkListResult) virtualNetworkListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vnlr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vnlr.NextLink)))
+}
+
+// VirtualNetworkListResultPage contains a page of VirtualNetwork values.
+type VirtualNetworkListResultPage struct {
+ fn func(context.Context, VirtualNetworkListResult) (VirtualNetworkListResult, error)
+ vnlr VirtualNetworkListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualNetworkListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vnlr)
+ if err != nil {
+ return err
+ }
+ page.vnlr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualNetworkListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualNetworkListResultPage) NotDone() bool {
+ return !page.vnlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualNetworkListResultPage) Response() VirtualNetworkListResult {
+ return page.vnlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualNetworkListResultPage) Values() []VirtualNetwork {
+ if page.vnlr.IsEmpty() {
+ return nil
+ }
+ return *page.vnlr.Value
+}
+
+// Creates a new instance of the VirtualNetworkListResultPage type.
+func NewVirtualNetworkListResultPage(cur VirtualNetworkListResult, getNextPage func(context.Context, VirtualNetworkListResult) (VirtualNetworkListResult, error)) VirtualNetworkListResultPage {
+ return VirtualNetworkListResultPage{
+ fn: getNextPage,
+ vnlr: cur,
+ }
+}
+
+// VirtualNetworkListUsageResult response for the virtual networks GetUsage API service call.
+type VirtualNetworkListUsageResult struct {
+ autorest.Response `json:"-"`
+ // Value - READ-ONLY; VirtualNetwork usage stats.
+ Value *[]VirtualNetworkUsage `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkListUsageResult.
+func (vnlur VirtualNetworkListUsageResult) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vnlur.NextLink != nil {
+ objectMap["nextLink"] = vnlur.NextLink
+ }
+ return json.Marshal(objectMap)
+}
+
+// VirtualNetworkListUsageResultIterator provides access to a complete listing of VirtualNetworkUsage
+// values.
+type VirtualNetworkListUsageResultIterator struct {
+ i int
+ page VirtualNetworkListUsageResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualNetworkListUsageResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkListUsageResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualNetworkListUsageResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualNetworkListUsageResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualNetworkListUsageResultIterator) Response() VirtualNetworkListUsageResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualNetworkListUsageResultIterator) Value() VirtualNetworkUsage {
+ if !iter.page.NotDone() {
+ return VirtualNetworkUsage{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualNetworkListUsageResultIterator type.
+func NewVirtualNetworkListUsageResultIterator(page VirtualNetworkListUsageResultPage) VirtualNetworkListUsageResultIterator {
+ return VirtualNetworkListUsageResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vnlur VirtualNetworkListUsageResult) IsEmpty() bool {
+ return vnlur.Value == nil || len(*vnlur.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vnlur VirtualNetworkListUsageResult) hasNextLink() bool {
+ return vnlur.NextLink != nil && len(*vnlur.NextLink) != 0
+}
+
+// virtualNetworkListUsageResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vnlur VirtualNetworkListUsageResult) virtualNetworkListUsageResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vnlur.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vnlur.NextLink)))
+}
+
+// VirtualNetworkListUsageResultPage contains a page of VirtualNetworkUsage values.
+type VirtualNetworkListUsageResultPage struct {
+ fn func(context.Context, VirtualNetworkListUsageResult) (VirtualNetworkListUsageResult, error)
+ vnlur VirtualNetworkListUsageResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualNetworkListUsageResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkListUsageResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vnlur)
+ if err != nil {
+ return err
+ }
+ page.vnlur = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualNetworkListUsageResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualNetworkListUsageResultPage) NotDone() bool {
+ return !page.vnlur.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualNetworkListUsageResultPage) Response() VirtualNetworkListUsageResult {
+ return page.vnlur
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualNetworkListUsageResultPage) Values() []VirtualNetworkUsage {
+ if page.vnlur.IsEmpty() {
+ return nil
+ }
+ return *page.vnlur.Value
+}
+
+// Creates a new instance of the VirtualNetworkListUsageResultPage type.
+func NewVirtualNetworkListUsageResultPage(cur VirtualNetworkListUsageResult, getNextPage func(context.Context, VirtualNetworkListUsageResult) (VirtualNetworkListUsageResult, error)) VirtualNetworkListUsageResultPage {
+ return VirtualNetworkListUsageResultPage{
+ fn: getNextPage,
+ vnlur: cur,
+ }
+}
+
+// VirtualNetworkPeering peerings in a virtual network resource.
+type VirtualNetworkPeering struct {
+ autorest.Response `json:"-"`
+ // VirtualNetworkPeeringPropertiesFormat - Properties of the virtual network peering.
+ *VirtualNetworkPeeringPropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VirtualNetworkPeering.
+func (vnp VirtualNetworkPeering) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vnp.VirtualNetworkPeeringPropertiesFormat != nil {
+ objectMap["properties"] = vnp.VirtualNetworkPeeringPropertiesFormat
+ }
+ if vnp.Name != nil {
+ objectMap["name"] = vnp.Name
+ }
+ if vnp.Etag != nil {
+ objectMap["etag"] = vnp.Etag
+ }
+ if vnp.ID != nil {
+ objectMap["id"] = vnp.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VirtualNetworkPeering struct.
+func (vnp *VirtualNetworkPeering) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var virtualNetworkPeeringPropertiesFormat VirtualNetworkPeeringPropertiesFormat
+ err = json.Unmarshal(*v, &virtualNetworkPeeringPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vnp.VirtualNetworkPeeringPropertiesFormat = &virtualNetworkPeeringPropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vnp.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vnp.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vnp.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VirtualNetworkPeeringListResult response for ListSubnets API service call. Retrieves all subnets that
+// belong to a virtual network.
+type VirtualNetworkPeeringListResult struct {
+ autorest.Response `json:"-"`
+ // Value - The peerings in a virtual network.
+ Value *[]VirtualNetworkPeering `json:"value,omitempty"`
+ // NextLink - The URL to get the next set of results.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// VirtualNetworkPeeringListResultIterator provides access to a complete listing of VirtualNetworkPeering
+// values.
+type VirtualNetworkPeeringListResultIterator struct {
+ i int
+ page VirtualNetworkPeeringListResultPage
+}
+
+// NextWithContext advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *VirtualNetworkPeeringListResultIterator) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkPeeringListResultIterator.NextWithContext")
+ defer func() {
+ sc := -1
+ if iter.Response().Response.Response != nil {
+ sc = iter.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err = iter.page.NextWithContext(ctx)
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (iter *VirtualNetworkPeeringListResultIterator) Next() error {
+ return iter.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter VirtualNetworkPeeringListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter VirtualNetworkPeeringListResultIterator) Response() VirtualNetworkPeeringListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter VirtualNetworkPeeringListResultIterator) Value() VirtualNetworkPeering {
+ if !iter.page.NotDone() {
+ return VirtualNetworkPeering{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// Creates a new instance of the VirtualNetworkPeeringListResultIterator type.
+func NewVirtualNetworkPeeringListResultIterator(page VirtualNetworkPeeringListResultPage) VirtualNetworkPeeringListResultIterator {
+ return VirtualNetworkPeeringListResultIterator{page: page}
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (vnplr VirtualNetworkPeeringListResult) IsEmpty() bool {
+ return vnplr.Value == nil || len(*vnplr.Value) == 0
+}
+
+// hasNextLink returns true if the NextLink is not empty.
+func (vnplr VirtualNetworkPeeringListResult) hasNextLink() bool {
+ return vnplr.NextLink != nil && len(*vnplr.NextLink) != 0
+}
+
+// virtualNetworkPeeringListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (vnplr VirtualNetworkPeeringListResult) virtualNetworkPeeringListResultPreparer(ctx context.Context) (*http.Request, error) {
+ if !vnplr.hasNextLink() {
+ return nil, nil
+ }
+ return autorest.Prepare((&http.Request{}).WithContext(ctx),
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(vnplr.NextLink)))
+}
+
+// VirtualNetworkPeeringListResultPage contains a page of VirtualNetworkPeering values.
+type VirtualNetworkPeeringListResultPage struct {
+ fn func(context.Context, VirtualNetworkPeeringListResult) (VirtualNetworkPeeringListResult, error)
+ vnplr VirtualNetworkPeeringListResult
+}
+
+// NextWithContext advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *VirtualNetworkPeeringListResultPage) NextWithContext(ctx context.Context) (err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkPeeringListResultPage.NextWithContext")
+ defer func() {
+ sc := -1
+ if page.Response().Response.Response != nil {
+ sc = page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ for {
+ next, err := page.fn(ctx, page.vnplr)
+ if err != nil {
+ return err
+ }
+ page.vnplr = next
+ if !next.hasNextLink() || !next.IsEmpty() {
+ break
+ }
+ }
+ return nil
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+// Deprecated: Use NextWithContext() instead.
+func (page *VirtualNetworkPeeringListResultPage) Next() error {
+ return page.NextWithContext(context.Background())
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page VirtualNetworkPeeringListResultPage) NotDone() bool {
+ return !page.vnplr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page VirtualNetworkPeeringListResultPage) Response() VirtualNetworkPeeringListResult {
+ return page.vnplr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page VirtualNetworkPeeringListResultPage) Values() []VirtualNetworkPeering {
+ if page.vnplr.IsEmpty() {
+ return nil
+ }
+ return *page.vnplr.Value
+}
+
+// Creates a new instance of the VirtualNetworkPeeringListResultPage type.
+func NewVirtualNetworkPeeringListResultPage(cur VirtualNetworkPeeringListResult, getNextPage func(context.Context, VirtualNetworkPeeringListResult) (VirtualNetworkPeeringListResult, error)) VirtualNetworkPeeringListResultPage {
+ return VirtualNetworkPeeringListResultPage{
+ fn: getNextPage,
+ vnplr: cur,
+ }
+}
+
+// VirtualNetworkPeeringPropertiesFormat properties of the virtual network peering.
+type VirtualNetworkPeeringPropertiesFormat struct {
+ // AllowVirtualNetworkAccess - Whether the VMs in the linked virtual network space would be able to access all the VMs in local Virtual network space.
+ AllowVirtualNetworkAccess *bool `json:"allowVirtualNetworkAccess,omitempty"`
+ // AllowForwardedTraffic - Whether the forwarded traffic from the VMs in the remote virtual network will be allowed/disallowed.
+ AllowForwardedTraffic *bool `json:"allowForwardedTraffic,omitempty"`
+ // AllowGatewayTransit - If gateway links can be used in remote virtual networking to link to this virtual network.
+ AllowGatewayTransit *bool `json:"allowGatewayTransit,omitempty"`
+ // UseRemoteGateways - If remote gateways can be used on this virtual network. If the flag is set to true, and allowGatewayTransit on remote peering is also true, virtual network will use gateways of remote virtual network for transit. Only one peering can have this flag set to true. This flag cannot be set if virtual network already has a gateway.
+ UseRemoteGateways *bool `json:"useRemoteGateways,omitempty"`
+ // RemoteVirtualNetwork - The reference of the remote virtual network. The remote virtual network can be in the same or different region (preview). See here to register for the preview and learn more (https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-create-peering).
+ RemoteVirtualNetwork *SubResource `json:"remoteVirtualNetwork,omitempty"`
+ // RemoteAddressSpace - The reference of the remote virtual network address space.
+ RemoteAddressSpace *AddressSpace `json:"remoteAddressSpace,omitempty"`
+ // PeeringState - The status of the virtual network peering. Possible values are 'Initiated', 'Connected', and 'Disconnected'. Possible values include: 'Initiated', 'Connected', 'Disconnected'
+ PeeringState VirtualNetworkPeeringState `json:"peeringState,omitempty"`
+ // ProvisioningState - The provisioning state of the resource.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// VirtualNetworkPeeringsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworkPeeringsCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkPeeringsClient) (VirtualNetworkPeering, error)
+}
+
+// VirtualNetworkPeeringsDeleteFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworkPeeringsDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworkPeeringsClient) (autorest.Response, error)
+}
+
+// VirtualNetworkPropertiesFormat properties of the virtual network.
+type VirtualNetworkPropertiesFormat struct {
+ // AddressSpace - The AddressSpace that contains an array of IP address ranges that can be used by subnets.
+ AddressSpace *AddressSpace `json:"addressSpace,omitempty"`
+ // DhcpOptions - The dhcpOptions that contains an array of DNS servers available to VMs deployed in the virtual network.
+ DhcpOptions *DhcpOptions `json:"dhcpOptions,omitempty"`
+ // Subnets - A list of subnets in a Virtual Network.
+ Subnets *[]Subnet `json:"subnets,omitempty"`
+ // VirtualNetworkPeerings - A list of peerings in a Virtual Network.
+ VirtualNetworkPeerings *[]VirtualNetworkPeering `json:"virtualNetworkPeerings,omitempty"`
+ // ResourceGUID - The resourceGuid property of the Virtual Network resource.
+ ResourceGUID *string `json:"resourceGuid,omitempty"`
+ // ProvisioningState - The provisioning state of the PublicIP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+ // EnableDdosProtection - Indicates if DDoS protection is enabled for all the protected resources in a Virtual Network.
+ EnableDdosProtection *bool `json:"enableDdosProtection,omitempty"`
+ // EnableVMProtection - Indicates if Vm protection is enabled for all the subnets in a Virtual Network.
+ EnableVMProtection *bool `json:"enableVmProtection,omitempty"`
+}
+
+// VirtualNetworksCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworksCreateOrUpdateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworksClient) (VirtualNetwork, error)
+}
+
+// VirtualNetworksDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type VirtualNetworksDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworksClient) (autorest.Response, error)
+}
+
+// VirtualNetworksUpdateTagsFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type VirtualNetworksUpdateTagsFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(VirtualNetworksClient) (VirtualNetwork, error)
+}
+
+// VirtualNetworkUsage usage details for subnet.
+type VirtualNetworkUsage struct {
+ // CurrentValue - READ-ONLY; Indicates number of IPs used from the Subnet.
+ CurrentValue *float64 `json:"currentValue,omitempty"`
+ // ID - READ-ONLY; Subnet identifier.
+ ID *string `json:"id,omitempty"`
+ // Limit - READ-ONLY; Indicates the size of the subnet.
+ Limit *float64 `json:"limit,omitempty"`
+ // Name - READ-ONLY; The name containing common and localized value for usage.
+ Name *VirtualNetworkUsageName `json:"name,omitempty"`
+ // Unit - READ-ONLY; Usage units. Returns 'Count'
+ Unit *string `json:"unit,omitempty"`
+}
+
+// VirtualNetworkUsageName usage strings container.
+type VirtualNetworkUsageName struct {
+ // LocalizedValue - READ-ONLY; Localized subnet size and usage string.
+ LocalizedValue *string `json:"localizedValue,omitempty"`
+ // Value - READ-ONLY; Subnet size and usage string.
+ Value *string `json:"value,omitempty"`
+}
+
+// VpnClientConfiguration vpnClientConfiguration for P2S client.
+type VpnClientConfiguration struct {
+ // VpnClientAddressPool - The reference of the address space resource which represents Address space for P2S VpnClient.
+ VpnClientAddressPool *AddressSpace `json:"vpnClientAddressPool,omitempty"`
+ // VpnClientRootCertificates - VpnClientRootCertificate for virtual network gateway.
+ VpnClientRootCertificates *[]VpnClientRootCertificate `json:"vpnClientRootCertificates,omitempty"`
+ // VpnClientRevokedCertificates - VpnClientRevokedCertificate for Virtual network gateway.
+ VpnClientRevokedCertificates *[]VpnClientRevokedCertificate `json:"vpnClientRevokedCertificates,omitempty"`
+ // VpnClientProtocols - VpnClientProtocols for Virtual network gateway.
+ VpnClientProtocols *[]VpnClientProtocol `json:"vpnClientProtocols,omitempty"`
+ // RadiusServerAddress - The radius server address property of the VirtualNetworkGateway resource for vpn client connection.
+ RadiusServerAddress *string `json:"radiusServerAddress,omitempty"`
+ // RadiusServerSecret - The radius secret property of the VirtualNetworkGateway resource for vpn client connection.
+ RadiusServerSecret *string `json:"radiusServerSecret,omitempty"`
+}
+
+// VpnClientParameters vpn Client Parameters for package generation
+type VpnClientParameters struct {
+ // ProcessorArchitecture - VPN client Processor Architecture. Possible values are: 'AMD64' and 'X86'. Possible values include: 'Amd64', 'X86'
+ ProcessorArchitecture ProcessorArchitecture `json:"processorArchitecture,omitempty"`
+ // AuthenticationMethod - VPN client Authentication Method. Possible values are: 'EAPTLS' and 'EAPMSCHAPv2'. Possible values include: 'EAPTLS', 'EAPMSCHAPv2'
+ AuthenticationMethod AuthenticationMethod `json:"authenticationMethod,omitempty"`
+ // RadiusServerAuthCertificate - The public certificate data for the radius server authentication certificate as a Base-64 encoded string. Required only if external radius authentication has been configured with EAPTLS authentication.
+ RadiusServerAuthCertificate *string `json:"radiusServerAuthCertificate,omitempty"`
+ // ClientRootCertificates - A list of client root certificates public certificate data encoded as Base-64 strings. Optional parameter for external radius based authentication with EAPTLS.
+ ClientRootCertificates *[]string `json:"clientRootCertificates,omitempty"`
+}
+
+// VpnClientRevokedCertificate VPN client revoked certificate of virtual network gateway.
+type VpnClientRevokedCertificate struct {
+ // VpnClientRevokedCertificatePropertiesFormat - Properties of the vpn client revoked certificate.
+ *VpnClientRevokedCertificatePropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VpnClientRevokedCertificate.
+func (vcrc VpnClientRevokedCertificate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vcrc.VpnClientRevokedCertificatePropertiesFormat != nil {
+ objectMap["properties"] = vcrc.VpnClientRevokedCertificatePropertiesFormat
+ }
+ if vcrc.Name != nil {
+ objectMap["name"] = vcrc.Name
+ }
+ if vcrc.Etag != nil {
+ objectMap["etag"] = vcrc.Etag
+ }
+ if vcrc.ID != nil {
+ objectMap["id"] = vcrc.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VpnClientRevokedCertificate struct.
+func (vcrc *VpnClientRevokedCertificate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var vpnClientRevokedCertificatePropertiesFormat VpnClientRevokedCertificatePropertiesFormat
+ err = json.Unmarshal(*v, &vpnClientRevokedCertificatePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vcrc.VpnClientRevokedCertificatePropertiesFormat = &vpnClientRevokedCertificatePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vcrc.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vcrc.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vcrc.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VpnClientRevokedCertificatePropertiesFormat properties of the revoked VPN client certificate of virtual
+// network gateway.
+type VpnClientRevokedCertificatePropertiesFormat struct {
+ // Thumbprint - The revoked VPN client certificate thumbprint.
+ Thumbprint *string `json:"thumbprint,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the VPN client revoked certificate resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VpnClientRevokedCertificatePropertiesFormat.
+func (vcrcpf VpnClientRevokedCertificatePropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vcrcpf.Thumbprint != nil {
+ objectMap["thumbprint"] = vcrcpf.Thumbprint
+ }
+ return json.Marshal(objectMap)
+}
+
+// VpnClientRootCertificate VPN client root certificate of virtual network gateway
+type VpnClientRootCertificate struct {
+ // VpnClientRootCertificatePropertiesFormat - Properties of the vpn client root certificate.
+ *VpnClientRootCertificatePropertiesFormat `json:"properties,omitempty"`
+ // Name - The name of the resource that is unique within a resource group. This name can be used to access the resource.
+ Name *string `json:"name,omitempty"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VpnClientRootCertificate.
+func (vcrc VpnClientRootCertificate) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vcrc.VpnClientRootCertificatePropertiesFormat != nil {
+ objectMap["properties"] = vcrc.VpnClientRootCertificatePropertiesFormat
+ }
+ if vcrc.Name != nil {
+ objectMap["name"] = vcrc.Name
+ }
+ if vcrc.Etag != nil {
+ objectMap["etag"] = vcrc.Etag
+ }
+ if vcrc.ID != nil {
+ objectMap["id"] = vcrc.ID
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for VpnClientRootCertificate struct.
+func (vcrc *VpnClientRootCertificate) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var vpnClientRootCertificatePropertiesFormat VpnClientRootCertificatePropertiesFormat
+ err = json.Unmarshal(*v, &vpnClientRootCertificatePropertiesFormat)
+ if err != nil {
+ return err
+ }
+ vcrc.VpnClientRootCertificatePropertiesFormat = &vpnClientRootCertificatePropertiesFormat
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ vcrc.Name = &name
+ }
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ vcrc.Etag = &etag
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ vcrc.ID = &ID
+ }
+ }
+ }
+
+ return nil
+}
+
+// VpnClientRootCertificatePropertiesFormat properties of SSL certificates of application gateway
+type VpnClientRootCertificatePropertiesFormat struct {
+ // PublicCertData - The certificate public data.
+ PublicCertData *string `json:"publicCertData,omitempty"`
+ // ProvisioningState - READ-ONLY; The provisioning state of the VPN client root certificate resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
+ ProvisioningState *string `json:"provisioningState,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for VpnClientRootCertificatePropertiesFormat.
+func (vcrcpf VpnClientRootCertificatePropertiesFormat) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if vcrcpf.PublicCertData != nil {
+ objectMap["publicCertData"] = vcrcpf.PublicCertData
+ }
+ return json.Marshal(objectMap)
+}
+
+// VpnDeviceScriptParameters vpn device configuration script generation parameters
+type VpnDeviceScriptParameters struct {
+ // Vendor - The vendor for the vpn device.
+ Vendor *string `json:"vendor,omitempty"`
+ // DeviceFamily - The device family for the vpn device.
+ DeviceFamily *string `json:"deviceFamily,omitempty"`
+ // FirmwareVersion - The firmware version for the vpn device.
+ FirmwareVersion *string `json:"firmwareVersion,omitempty"`
+}
+
+// Watcher network watcher in a resource group.
+type Watcher struct {
+ autorest.Response `json:"-"`
+ // Etag - A unique read-only string that changes whenever the resource is updated.
+ Etag *string `json:"etag,omitempty"`
+ *WatcherPropertiesFormat `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type.
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Watcher.
+func (w Watcher) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if w.Etag != nil {
+ objectMap["etag"] = w.Etag
+ }
+ if w.WatcherPropertiesFormat != nil {
+ objectMap["properties"] = w.WatcherPropertiesFormat
+ }
+ if w.ID != nil {
+ objectMap["id"] = w.ID
+ }
+ if w.Location != nil {
+ objectMap["location"] = w.Location
+ }
+ if w.Tags != nil {
+ objectMap["tags"] = w.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Watcher struct.
+func (w *Watcher) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "etag":
+ if v != nil {
+ var etag string
+ err = json.Unmarshal(*v, &etag)
+ if err != nil {
+ return err
+ }
+ w.Etag = &etag
+ }
+ case "properties":
+ if v != nil {
+ var watcherPropertiesFormat WatcherPropertiesFormat
+ err = json.Unmarshal(*v, &watcherPropertiesFormat)
+ if err != nil {
+ return err
+ }
+ w.WatcherPropertiesFormat = &watcherPropertiesFormat
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ w.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ w.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ w.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ w.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ w.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// WatcherListResult list of network watcher resources.
+type WatcherListResult struct {
+ autorest.Response `json:"-"`
+ Value *[]Watcher `json:"value,omitempty"`
+}
+
+// WatcherPropertiesFormat the network watcher properties.
+type WatcherPropertiesFormat struct {
+ // ProvisioningState - READ-ONLY; The provisioning state of the resource. Possible values include: 'Succeeded', 'Updating', 'Deleting', 'Failed'
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+}
+
+// WatchersCheckConnectivityFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersCheckConnectivityFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (ConnectivityInformation, error)
+}
+
+// WatchersDeleteFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type WatchersDeleteFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (autorest.Response, error)
+}
+
+// WatchersGetAzureReachabilityReportFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersGetAzureReachabilityReportFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (AzureReachabilityReport, error)
+}
+
+// WatchersGetFlowLogStatusFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersGetFlowLogStatusFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (FlowLogInformation, error)
+}
+
+// WatchersGetNextHopFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type WatchersGetNextHopFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (NextHopResult, error)
+}
+
+// WatchersGetTroubleshootingFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersGetTroubleshootingFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (TroubleshootingResult, error)
+}
+
+// WatchersGetTroubleshootingResultFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersGetTroubleshootingResultFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (TroubleshootingResult, error)
+}
+
+// WatchersGetVMSecurityRulesFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersGetVMSecurityRulesFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (SecurityGroupViewResult, error)
+}
+
+// WatchersListAvailableProvidersFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersListAvailableProvidersFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (AvailableProvidersList, error)
+}
+
+// WatchersSetFlowLogConfigurationFuture an abstraction for monitoring and retrieving the results of a
+// long-running operation.
+type WatchersSetFlowLogConfigurationFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (FlowLogInformation, error)
+}
+
+// WatchersVerifyIPFlowFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type WatchersVerifyIPFlowFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(WatchersClient) (VerificationIPFlowResult, error)
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/operations.go
new file mode 100644
index 00000000000..9199a6eb7ed
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/operations.go
@@ -0,0 +1,151 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// OperationsClient is the network Client
+type OperationsClient struct {
+ BaseClient
+}
+
+// NewOperationsClient creates an instance of the OperationsClient client.
+func NewOperationsClient(subscriptionID string) OperationsClient {
+ return NewOperationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewOperationsClientWithBaseURI creates an instance of the OperationsClient client using a custom endpoint. Use this
+// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+ return OperationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List lists all of the available Network Rest API operations.
+func (client OperationsClient) List(ctx context.Context) (result OperationListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List")
+ defer func() {
+ sc := -1
+ if result.olr.Response.Response != nil {
+ sc = result.olr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.OperationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.olr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.OperationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.olr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.OperationsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.olr.hasNextLink() && result.olr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Network/operations"),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client OperationsClient) ListResponder(resp *http.Response) (result OperationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client OperationsClient) listNextResults(ctx context.Context, lastResults OperationListResult) (result OperationListResult, err error) {
+ req, err := lastResults.operationListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.OperationsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.OperationsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.OperationsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client OperationsClient) ListComplete(ctx context.Context) (result OperationListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/packetcaptures.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/packetcaptures.go
new file mode 100644
index 00000000000..c5a30948d0e
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/packetcaptures.go
@@ -0,0 +1,599 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// PacketCapturesClient is the network Client
+type PacketCapturesClient struct {
+ BaseClient
+}
+
+// NewPacketCapturesClient creates an instance of the PacketCapturesClient client.
+func NewPacketCapturesClient(subscriptionID string) PacketCapturesClient {
+ return NewPacketCapturesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewPacketCapturesClientWithBaseURI creates an instance of the PacketCapturesClient client using a custom endpoint.
+// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewPacketCapturesClientWithBaseURI(baseURI string, subscriptionID string) PacketCapturesClient {
+ return PacketCapturesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Create create and start a packet capture on the specified VM.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// packetCaptureName - the name of the packet capture session.
+// parameters - parameters that define the create packet capture operation.
+func (client PacketCapturesClient) Create(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string, parameters PacketCapture) (result PacketCapturesCreateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PacketCapturesClient.Create")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.PacketCaptureParameters", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.PacketCaptureParameters.Target", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.PacketCaptureParameters.StorageLocation", Name: validation.Null, Rule: true, Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.PacketCapturesClient", "Create", err.Error())
+ }
+
+ req, err := client.CreatePreparer(ctx, resourceGroupName, networkWatcherName, packetCaptureName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Create", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Create", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreatePreparer prepares the Create request.
+func (client PacketCapturesClient) CreatePreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string, parameters PacketCapture) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "packetCaptureName": autorest.Encode("path", packetCaptureName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/packetCaptures/{packetCaptureName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateSender sends the Create request. The method will close the
+// http.Response Body if it receives an error.
+func (client PacketCapturesClient) CreateSender(req *http.Request) (future PacketCapturesCreateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client PacketCapturesClient) (pcr PacketCaptureResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesCreateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.PacketCapturesCreateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ pcr.Response.Response, err = future.GetResult(sender)
+ if pcr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesCreateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && pcr.Response.Response.StatusCode != http.StatusNoContent {
+ pcr, err = client.CreateResponder(pcr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesCreateFuture", "Result", pcr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateResponder handles the response to the Create request. The method always
+// closes the http.Response Body.
+func (client PacketCapturesClient) CreateResponder(resp *http.Response) (result PacketCaptureResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified packet capture session.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// packetCaptureName - the name of the packet capture session.
+func (client PacketCapturesClient) Delete(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (result PacketCapturesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PacketCapturesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, networkWatcherName, packetCaptureName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client PacketCapturesClient) DeletePreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "packetCaptureName": autorest.Encode("path", packetCaptureName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/packetCaptures/{packetCaptureName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client PacketCapturesClient) DeleteSender(req *http.Request) (future PacketCapturesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client PacketCapturesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.PacketCapturesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client PacketCapturesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets a packet capture session by name.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// packetCaptureName - the name of the packet capture session.
+func (client PacketCapturesClient) Get(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (result PacketCaptureResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PacketCapturesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkWatcherName, packetCaptureName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client PacketCapturesClient) GetPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "packetCaptureName": autorest.Encode("path", packetCaptureName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/packetCaptures/{packetCaptureName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client PacketCapturesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client PacketCapturesClient) GetResponder(resp *http.Response) (result PacketCaptureResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetStatus query the status of a running packet capture session.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the Network Watcher resource.
+// packetCaptureName - the name given to the packet capture session.
+func (client PacketCapturesClient) GetStatus(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (result PacketCapturesGetStatusFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PacketCapturesClient.GetStatus")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetStatusPreparer(ctx, resourceGroupName, networkWatcherName, packetCaptureName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "GetStatus", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetStatusSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "GetStatus", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetStatusPreparer prepares the GetStatus request.
+func (client PacketCapturesClient) GetStatusPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "packetCaptureName": autorest.Encode("path", packetCaptureName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/packetCaptures/{packetCaptureName}/queryStatus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetStatusSender sends the GetStatus request. The method will close the
+// http.Response Body if it receives an error.
+func (client PacketCapturesClient) GetStatusSender(req *http.Request) (future PacketCapturesGetStatusFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client PacketCapturesClient) (pcqsr PacketCaptureQueryStatusResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesGetStatusFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.PacketCapturesGetStatusFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ pcqsr.Response.Response, err = future.GetResult(sender)
+ if pcqsr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesGetStatusFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && pcqsr.Response.Response.StatusCode != http.StatusNoContent {
+ pcqsr, err = client.GetStatusResponder(pcqsr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesGetStatusFuture", "Result", pcqsr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetStatusResponder handles the response to the GetStatus request. The method always
+// closes the http.Response Body.
+func (client PacketCapturesClient) GetStatusResponder(resp *http.Response) (result PacketCaptureQueryStatusResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all packet capture sessions within the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the Network Watcher resource.
+func (client PacketCapturesClient) List(ctx context.Context, resourceGroupName string, networkWatcherName string) (result PacketCaptureListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PacketCapturesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx, resourceGroupName, networkWatcherName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client PacketCapturesClient) ListPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/packetCaptures", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client PacketCapturesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client PacketCapturesClient) ListResponder(resp *http.Response) (result PacketCaptureListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Stop stops a specified packet capture session.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// packetCaptureName - the name of the packet capture session.
+func (client PacketCapturesClient) Stop(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (result PacketCapturesStopFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PacketCapturesClient.Stop")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.StopPreparer(ctx, resourceGroupName, networkWatcherName, packetCaptureName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Stop", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.StopSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesClient", "Stop", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// StopPreparer prepares the Stop request.
+func (client PacketCapturesClient) StopPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, packetCaptureName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "packetCaptureName": autorest.Encode("path", packetCaptureName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/packetCaptures/{packetCaptureName}/stop", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// StopSender sends the Stop request. The method will close the
+// http.Response Body if it receives an error.
+func (client PacketCapturesClient) StopSender(req *http.Request) (future PacketCapturesStopFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client PacketCapturesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PacketCapturesStopFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.PacketCapturesStopFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// StopResponder handles the response to the Stop request. The method always
+// closes the http.Response Body.
+func (client PacketCapturesClient) StopResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/publicipaddresses.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/publicipaddresses.go
new file mode 100644
index 00000000000..e4be47ff54c
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/publicipaddresses.go
@@ -0,0 +1,994 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// PublicIPAddressesClient is the network Client
+type PublicIPAddressesClient struct {
+ BaseClient
+}
+
+// NewPublicIPAddressesClient creates an instance of the PublicIPAddressesClient client.
+func NewPublicIPAddressesClient(subscriptionID string) PublicIPAddressesClient {
+ return NewPublicIPAddressesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewPublicIPAddressesClientWithBaseURI creates an instance of the PublicIPAddressesClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewPublicIPAddressesClientWithBaseURI(baseURI string, subscriptionID string) PublicIPAddressesClient {
+ return PublicIPAddressesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a static or dynamic public IP address.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// publicIPAddressName - the name of the public IP address.
+// parameters - parameters supplied to the create or update public IP address operation.
+func (client PublicIPAddressesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters PublicIPAddress) (result PublicIPAddressesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat.IPConfiguration", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat.IPConfiguration.IPConfigurationPropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat.IPConfiguration.IPConfigurationPropertiesFormat.PublicIPAddress", Name: validation.Null, Rule: false, Chain: nil}}},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.PublicIPAddressesClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, publicIPAddressName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client PublicIPAddressesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters PublicIPAddress) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "publicIpAddressName": autorest.Encode("path", publicIPAddressName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) CreateOrUpdateSender(req *http.Request) (future PublicIPAddressesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client PublicIPAddressesClient) (pia PublicIPAddress, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.PublicIPAddressesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ pia.Response.Response, err = future.GetResult(sender)
+ if pia.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && pia.Response.Response.StatusCode != http.StatusNoContent {
+ pia, err = client.CreateOrUpdateResponder(pia.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesCreateOrUpdateFuture", "Result", pia.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) CreateOrUpdateResponder(resp *http.Response) (result PublicIPAddress, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified public IP address.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// publicIPAddressName - the name of the subnet.
+func (client PublicIPAddressesClient) Delete(ctx context.Context, resourceGroupName string, publicIPAddressName string) (result PublicIPAddressesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, publicIPAddressName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client PublicIPAddressesClient) DeletePreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "publicIpAddressName": autorest.Encode("path", publicIPAddressName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) DeleteSender(req *http.Request) (future PublicIPAddressesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client PublicIPAddressesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.PublicIPAddressesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified public IP address in a specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// publicIPAddressName - the name of the subnet.
+// expand - expands referenced resources.
+func (client PublicIPAddressesClient) Get(ctx context.Context, resourceGroupName string, publicIPAddressName string, expand string) (result PublicIPAddress, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, publicIPAddressName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client PublicIPAddressesClient) GetPreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "publicIpAddressName": autorest.Encode("path", publicIPAddressName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) GetResponder(resp *http.Response) (result PublicIPAddress, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVirtualMachineScaleSetPublicIPAddress get the specified public IP address in a virtual machine scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+// virtualmachineIndex - the virtual machine index.
+// networkInterfaceName - the name of the network interface.
+// IPConfigurationName - the name of the IP configuration.
+// publicIPAddressName - the name of the public IP Address.
+// expand - expands referenced resources.
+func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddress(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string, publicIPAddressName string, expand string) (result PublicIPAddress, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.GetVirtualMachineScaleSetPublicIPAddress")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetVirtualMachineScaleSetPublicIPAddressPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName, publicIPAddressName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "GetVirtualMachineScaleSetPublicIPAddress", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVirtualMachineScaleSetPublicIPAddressSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "GetVirtualMachineScaleSetPublicIPAddress", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVirtualMachineScaleSetPublicIPAddressResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "GetVirtualMachineScaleSetPublicIPAddress", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetVirtualMachineScaleSetPublicIPAddressPreparer prepares the GetVirtualMachineScaleSetPublicIPAddress request.
+func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string, publicIPAddressName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "ipConfigurationName": autorest.Encode("path", IPConfigurationName),
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "publicIpAddressName": autorest.Encode("path", publicIPAddressName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces/{networkInterfaceName}/ipconfigurations/{ipConfigurationName}/publicipaddresses/{publicIpAddressName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetVirtualMachineScaleSetPublicIPAddressSender sends the GetVirtualMachineScaleSetPublicIPAddress request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetVirtualMachineScaleSetPublicIPAddressResponder handles the response to the GetVirtualMachineScaleSetPublicIPAddress request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressResponder(resp *http.Response) (result PublicIPAddress, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all public IP addresses in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client PublicIPAddressesClient) List(ctx context.Context, resourceGroupName string) (result PublicIPAddressListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.List")
+ defer func() {
+ sc := -1
+ if result.pialr.Response.Response != nil {
+ sc = result.pialr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.pialr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.pialr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.pialr.hasNextLink() && result.pialr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client PublicIPAddressesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) ListResponder(resp *http.Response) (result PublicIPAddressListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client PublicIPAddressesClient) listNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) {
+ req, err := lastResults.publicIPAddressListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client PublicIPAddressesClient) ListComplete(ctx context.Context, resourceGroupName string) (result PublicIPAddressListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all the public IP addresses in a subscription.
+func (client PublicIPAddressesClient) ListAll(ctx context.Context) (result PublicIPAddressListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.pialr.Response.Response != nil {
+ sc = result.pialr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.pialr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.pialr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.pialr.hasNextLink() && result.pialr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client PublicIPAddressesClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/publicIPAddresses", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) ListAllResponder(resp *http.Response) (result PublicIPAddressListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client PublicIPAddressesClient) listAllNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) {
+ req, err := lastResults.publicIPAddressListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client PublicIPAddressesClient) ListAllComplete(ctx context.Context) (result PublicIPAddressListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// ListVirtualMachineScaleSetPublicIPAddresses gets information about all public IP addresses on a virtual machine
+// scale set level.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddresses(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (result PublicIPAddressListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetPublicIPAddresses")
+ defer func() {
+ sc := -1
+ if result.pialr.Response.Response != nil {
+ sc = result.pialr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listVirtualMachineScaleSetPublicIPAddressesNextResults
+ req, err := client.ListVirtualMachineScaleSetPublicIPAddressesPreparer(ctx, resourceGroupName, virtualMachineScaleSetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetPublicIPAddresses", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVirtualMachineScaleSetPublicIPAddressesSender(req)
+ if err != nil {
+ result.pialr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetPublicIPAddresses", resp, "Failure sending request")
+ return
+ }
+
+ result.pialr, err = client.ListVirtualMachineScaleSetPublicIPAddressesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetPublicIPAddresses", resp, "Failure responding to request")
+ return
+ }
+ if result.pialr.hasNextLink() && result.pialr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListVirtualMachineScaleSetPublicIPAddressesPreparer prepares the ListVirtualMachineScaleSetPublicIPAddresses request.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/publicipaddresses", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListVirtualMachineScaleSetPublicIPAddressesSender sends the ListVirtualMachineScaleSetPublicIPAddresses request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListVirtualMachineScaleSetPublicIPAddressesResponder handles the response to the ListVirtualMachineScaleSetPublicIPAddresses request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesResponder(resp *http.Response) (result PublicIPAddressListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listVirtualMachineScaleSetPublicIPAddressesNextResults retrieves the next set of results, if any.
+func (client PublicIPAddressesClient) listVirtualMachineScaleSetPublicIPAddressesNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) {
+ req, err := lastResults.publicIPAddressListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetPublicIPAddressesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListVirtualMachineScaleSetPublicIPAddressesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetPublicIPAddressesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListVirtualMachineScaleSetPublicIPAddressesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetPublicIPAddressesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListVirtualMachineScaleSetPublicIPAddressesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (result PublicIPAddressListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetPublicIPAddresses")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListVirtualMachineScaleSetPublicIPAddresses(ctx, resourceGroupName, virtualMachineScaleSetName)
+ return
+}
+
+// ListVirtualMachineScaleSetVMPublicIPAddresses gets information about all public IP addresses in a virtual machine IP
+// configuration in a virtual machine scale set.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualMachineScaleSetName - the name of the virtual machine scale set.
+// virtualmachineIndex - the virtual machine index.
+// networkInterfaceName - the network interface name.
+// IPConfigurationName - the IP configuration name.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddresses(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string) (result PublicIPAddressListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetVMPublicIPAddresses")
+ defer func() {
+ sc := -1
+ if result.pialr.Response.Response != nil {
+ sc = result.pialr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listVirtualMachineScaleSetVMPublicIPAddressesNextResults
+ req, err := client.ListVirtualMachineScaleSetVMPublicIPAddressesPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetVMPublicIPAddresses", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVirtualMachineScaleSetVMPublicIPAddressesSender(req)
+ if err != nil {
+ result.pialr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetVMPublicIPAddresses", resp, "Failure sending request")
+ return
+ }
+
+ result.pialr, err = client.ListVirtualMachineScaleSetVMPublicIPAddressesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetVMPublicIPAddresses", resp, "Failure responding to request")
+ return
+ }
+ if result.pialr.hasNextLink() && result.pialr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListVirtualMachineScaleSetVMPublicIPAddressesPreparer prepares the ListVirtualMachineScaleSetVMPublicIPAddresses request.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "ipConfigurationName": autorest.Encode("path", IPConfigurationName),
+ "networkInterfaceName": autorest.Encode("path", networkInterfaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex),
+ "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName),
+ }
+
+ const APIVersion = "2017-03-30"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces/{networkInterfaceName}/ipconfigurations/{ipConfigurationName}/publicipaddresses", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListVirtualMachineScaleSetVMPublicIPAddressesSender sends the ListVirtualMachineScaleSetVMPublicIPAddresses request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListVirtualMachineScaleSetVMPublicIPAddressesResponder handles the response to the ListVirtualMachineScaleSetVMPublicIPAddresses request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesResponder(resp *http.Response) (result PublicIPAddressListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listVirtualMachineScaleSetVMPublicIPAddressesNextResults retrieves the next set of results, if any.
+func (client PublicIPAddressesClient) listVirtualMachineScaleSetVMPublicIPAddressesNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) {
+ req, err := lastResults.publicIPAddressListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetVMPublicIPAddressesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListVirtualMachineScaleSetVMPublicIPAddressesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetVMPublicIPAddressesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListVirtualMachineScaleSetVMPublicIPAddressesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetVMPublicIPAddressesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListVirtualMachineScaleSetVMPublicIPAddressesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string) (result PublicIPAddressListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetVMPublicIPAddresses")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListVirtualMachineScaleSetVMPublicIPAddresses(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName)
+ return
+}
+
+// UpdateTags updates public IP address tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// publicIPAddressName - the name of the public IP address.
+// parameters - parameters supplied to update public IP address tags.
+func (client PublicIPAddressesClient) UpdateTags(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters TagsObject) (result PublicIPAddressesUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, publicIPAddressName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client PublicIPAddressesClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "publicIpAddressName": autorest.Encode("path", publicIPAddressName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client PublicIPAddressesClient) UpdateTagsSender(req *http.Request) (future PublicIPAddressesUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client PublicIPAddressesClient) (pia PublicIPAddress, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.PublicIPAddressesUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ pia.Response.Response, err = future.GetResult(sender)
+ if pia.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && pia.Response.Response.StatusCode != http.StatusNoContent {
+ pia, err = client.UpdateTagsResponder(pia.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.PublicIPAddressesUpdateTagsFuture", "Result", pia.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client PublicIPAddressesClient) UpdateTagsResponder(resp *http.Response) (result PublicIPAddress, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routefilterrules.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routefilterrules.go
new file mode 100644
index 00000000000..9580aa4552a
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routefilterrules.go
@@ -0,0 +1,556 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// RouteFilterRulesClient is the network Client
+type RouteFilterRulesClient struct {
+ BaseClient
+}
+
+// NewRouteFilterRulesClient creates an instance of the RouteFilterRulesClient client.
+func NewRouteFilterRulesClient(subscriptionID string) RouteFilterRulesClient {
+ return NewRouteFilterRulesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewRouteFilterRulesClientWithBaseURI creates an instance of the RouteFilterRulesClient client using a custom
+// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
+// stack).
+func NewRouteFilterRulesClientWithBaseURI(baseURI string, subscriptionID string) RouteFilterRulesClient {
+ return RouteFilterRulesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a route in the specified route filter.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+// ruleName - the name of the route filter rule.
+// routeFilterRuleParameters - parameters supplied to the create or update route filter rule operation.
+func (client RouteFilterRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string, routeFilterRuleParameters RouteFilterRule) (result RouteFilterRulesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRulesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: routeFilterRuleParameters,
+ Constraints: []validation.Constraint{{Target: "routeFilterRuleParameters.RouteFilterRulePropertiesFormat", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "routeFilterRuleParameters.RouteFilterRulePropertiesFormat.RouteFilterRuleType", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "routeFilterRuleParameters.RouteFilterRulePropertiesFormat.Communities", Name: validation.Null, Rule: true, Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.RouteFilterRulesClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, routeFilterName, ruleName, routeFilterRuleParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client RouteFilterRulesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string, routeFilterRuleParameters RouteFilterRule) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "ruleName": autorest.Encode("path", ruleName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ routeFilterRuleParameters.Etag = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}/routeFilterRules/{ruleName}", pathParameters),
+ autorest.WithJSON(routeFilterRuleParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFilterRulesClient) CreateOrUpdateSender(req *http.Request) (future RouteFilterRulesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteFilterRulesClient) (rfr RouteFilterRule, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteFilterRulesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ rfr.Response.Response, err = future.GetResult(sender)
+ if rfr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && rfr.Response.Response.StatusCode != http.StatusNoContent {
+ rfr, err = client.CreateOrUpdateResponder(rfr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesCreateOrUpdateFuture", "Result", rfr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client RouteFilterRulesClient) CreateOrUpdateResponder(resp *http.Response) (result RouteFilterRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified rule from a route filter.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+// ruleName - the name of the rule.
+func (client RouteFilterRulesClient) Delete(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string) (result RouteFilterRulesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRulesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, routeFilterName, ruleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client RouteFilterRulesClient) DeletePreparer(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "ruleName": autorest.Encode("path", ruleName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}/routeFilterRules/{ruleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFilterRulesClient) DeleteSender(req *http.Request) (future RouteFilterRulesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteFilterRulesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteFilterRulesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client RouteFilterRulesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified rule from a route filter.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+// ruleName - the name of the rule.
+func (client RouteFilterRulesClient) Get(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string) (result RouteFilterRule, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRulesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, routeFilterName, ruleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client RouteFilterRulesClient) GetPreparer(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "ruleName": autorest.Encode("path", ruleName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}/routeFilterRules/{ruleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFilterRulesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client RouteFilterRulesClient) GetResponder(resp *http.Response) (result RouteFilterRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByRouteFilter gets all RouteFilterRules in a route filter.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+func (client RouteFilterRulesClient) ListByRouteFilter(ctx context.Context, resourceGroupName string, routeFilterName string) (result RouteFilterRuleListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRulesClient.ListByRouteFilter")
+ defer func() {
+ sc := -1
+ if result.rfrlr.Response.Response != nil {
+ sc = result.rfrlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listByRouteFilterNextResults
+ req, err := client.ListByRouteFilterPreparer(ctx, resourceGroupName, routeFilterName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "ListByRouteFilter", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByRouteFilterSender(req)
+ if err != nil {
+ result.rfrlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "ListByRouteFilter", resp, "Failure sending request")
+ return
+ }
+
+ result.rfrlr, err = client.ListByRouteFilterResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "ListByRouteFilter", resp, "Failure responding to request")
+ return
+ }
+ if result.rfrlr.hasNextLink() && result.rfrlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListByRouteFilterPreparer prepares the ListByRouteFilter request.
+func (client RouteFilterRulesClient) ListByRouteFilterPreparer(ctx context.Context, resourceGroupName string, routeFilterName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}/routeFilterRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByRouteFilterSender sends the ListByRouteFilter request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFilterRulesClient) ListByRouteFilterSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByRouteFilterResponder handles the response to the ListByRouteFilter request. The method always
+// closes the http.Response Body.
+func (client RouteFilterRulesClient) ListByRouteFilterResponder(resp *http.Response) (result RouteFilterRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByRouteFilterNextResults retrieves the next set of results, if any.
+func (client RouteFilterRulesClient) listByRouteFilterNextResults(ctx context.Context, lastResults RouteFilterRuleListResult) (result RouteFilterRuleListResult, err error) {
+ req, err := lastResults.routeFilterRuleListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "listByRouteFilterNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByRouteFilterSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "listByRouteFilterNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByRouteFilterResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "listByRouteFilterNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByRouteFilterComplete enumerates all values, automatically crossing page boundaries as required.
+func (client RouteFilterRulesClient) ListByRouteFilterComplete(ctx context.Context, resourceGroupName string, routeFilterName string) (result RouteFilterRuleListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRulesClient.ListByRouteFilter")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListByRouteFilter(ctx, resourceGroupName, routeFilterName)
+ return
+}
+
+// Update updates a route in the specified route filter.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+// ruleName - the name of the route filter rule.
+// routeFilterRuleParameters - parameters supplied to the update route filter rule operation.
+func (client RouteFilterRulesClient) Update(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string, routeFilterRuleParameters PatchRouteFilterRule) (result RouteFilterRulesUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFilterRulesClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, routeFilterName, ruleName, routeFilterRuleParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client RouteFilterRulesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, routeFilterName string, ruleName string, routeFilterRuleParameters PatchRouteFilterRule) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "ruleName": autorest.Encode("path", ruleName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ routeFilterRuleParameters.Name = nil
+ routeFilterRuleParameters.Etag = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}/routeFilterRules/{ruleName}", pathParameters),
+ autorest.WithJSON(routeFilterRuleParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFilterRulesClient) UpdateSender(req *http.Request) (future RouteFilterRulesUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteFilterRulesClient) (rfr RouteFilterRule, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteFilterRulesUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ rfr.Response.Response, err = future.GetResult(sender)
+ if rfr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && rfr.Response.Response.StatusCode != http.StatusNoContent {
+ rfr, err = client.UpdateResponder(rfr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFilterRulesUpdateFuture", "Result", rfr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client RouteFilterRulesClient) UpdateResponder(resp *http.Response) (result RouteFilterRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routefilters.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routefilters.go
new file mode 100644
index 00000000000..559772ac5e3
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routefilters.go
@@ -0,0 +1,653 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// RouteFiltersClient is the network Client
+type RouteFiltersClient struct {
+ BaseClient
+}
+
+// NewRouteFiltersClient creates an instance of the RouteFiltersClient client.
+func NewRouteFiltersClient(subscriptionID string) RouteFiltersClient {
+ return NewRouteFiltersClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewRouteFiltersClientWithBaseURI creates an instance of the RouteFiltersClient client using a custom endpoint. Use
+// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewRouteFiltersClientWithBaseURI(baseURI string, subscriptionID string) RouteFiltersClient {
+ return RouteFiltersClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a route filter in a specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+// routeFilterParameters - parameters supplied to the create or update route filter operation.
+func (client RouteFiltersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, routeFilterName string, routeFilterParameters RouteFilter) (result RouteFiltersCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, routeFilterName, routeFilterParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client RouteFiltersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, routeFilterName string, routeFilterParameters RouteFilter) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ routeFilterParameters.Etag = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}", pathParameters),
+ autorest.WithJSON(routeFilterParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFiltersClient) CreateOrUpdateSender(req *http.Request) (future RouteFiltersCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteFiltersClient) (rf RouteFilter, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteFiltersCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ rf.Response.Response, err = future.GetResult(sender)
+ if rf.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && rf.Response.Response.StatusCode != http.StatusNoContent {
+ rf, err = client.CreateOrUpdateResponder(rf.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersCreateOrUpdateFuture", "Result", rf.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client RouteFiltersClient) CreateOrUpdateResponder(resp *http.Response) (result RouteFilter, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified route filter.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+func (client RouteFiltersClient) Delete(ctx context.Context, resourceGroupName string, routeFilterName string) (result RouteFiltersDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, routeFilterName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client RouteFiltersClient) DeletePreparer(ctx context.Context, resourceGroupName string, routeFilterName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFiltersClient) DeleteSender(req *http.Request) (future RouteFiltersDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteFiltersClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteFiltersDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client RouteFiltersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified route filter.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+// expand - expands referenced express route bgp peering resources.
+func (client RouteFiltersClient) Get(ctx context.Context, resourceGroupName string, routeFilterName string, expand string) (result RouteFilter, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, routeFilterName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client RouteFiltersClient) GetPreparer(ctx context.Context, resourceGroupName string, routeFilterName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFiltersClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client RouteFiltersClient) GetResponder(resp *http.Response) (result RouteFilter, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all route filters in a subscription.
+func (client RouteFiltersClient) List(ctx context.Context) (result RouteFilterListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.List")
+ defer func() {
+ sc := -1
+ if result.rflr.Response.Response != nil {
+ sc = result.rflr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.rflr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.rflr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.rflr.hasNextLink() && result.rflr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client RouteFiltersClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/routeFilters", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFiltersClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client RouteFiltersClient) ListResponder(resp *http.Response) (result RouteFilterListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client RouteFiltersClient) listNextResults(ctx context.Context, lastResults RouteFilterListResult) (result RouteFilterListResult, err error) {
+ req, err := lastResults.routeFilterListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.RouteFiltersClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.RouteFiltersClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client RouteFiltersClient) ListComplete(ctx context.Context) (result RouteFilterListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx)
+ return
+}
+
+// ListByResourceGroup gets all route filters in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client RouteFiltersClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result RouteFilterListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.rflr.Response.Response != nil {
+ sc = result.rflr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listByResourceGroupNextResults
+ req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.rflr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result.rflr, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "ListByResourceGroup", resp, "Failure responding to request")
+ return
+ }
+ if result.rflr.hasNextLink() && result.rflr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client RouteFiltersClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFiltersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client RouteFiltersClient) ListByResourceGroupResponder(resp *http.Response) (result RouteFilterListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByResourceGroupNextResults retrieves the next set of results, if any.
+func (client RouteFiltersClient) listByResourceGroupNextResults(ctx context.Context, lastResults RouteFilterListResult) (result RouteFilterListResult, err error) {
+ req, err := lastResults.routeFilterListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.RouteFiltersClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.RouteFiltersClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
+func (client RouteFiltersClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result RouteFilterListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
+ return
+}
+
+// Update updates a route filter in a specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeFilterName - the name of the route filter.
+// routeFilterParameters - parameters supplied to the update route filter operation.
+func (client RouteFiltersClient) Update(ctx context.Context, resourceGroupName string, routeFilterName string, routeFilterParameters PatchRouteFilter) (result RouteFiltersUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteFiltersClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, routeFilterName, routeFilterParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersClient", "Update", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client RouteFiltersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, routeFilterName string, routeFilterParameters PatchRouteFilter) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeFilterName": autorest.Encode("path", routeFilterName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ routeFilterParameters.Name = nil
+ routeFilterParameters.Etag = nil
+ routeFilterParameters.Type = nil
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeFilters/{routeFilterName}", pathParameters),
+ autorest.WithJSON(routeFilterParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteFiltersClient) UpdateSender(req *http.Request) (future RouteFiltersUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteFiltersClient) (rf RouteFilter, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteFiltersUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ rf.Response.Response, err = future.GetResult(sender)
+ if rf.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && rf.Response.Response.StatusCode != http.StatusNoContent {
+ rf, err = client.UpdateResponder(rf.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteFiltersUpdateFuture", "Result", rf.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client RouteFiltersClient) UpdateResponder(resp *http.Response) (result RouteFilter, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routes.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routes.go
new file mode 100644
index 00000000000..e395b3ef5ce
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routes.go
@@ -0,0 +1,436 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// RoutesClient is the network Client
+type RoutesClient struct {
+ BaseClient
+}
+
+// NewRoutesClient creates an instance of the RoutesClient client.
+func NewRoutesClient(subscriptionID string) RoutesClient {
+ return NewRoutesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewRoutesClientWithBaseURI creates an instance of the RoutesClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewRoutesClientWithBaseURI(baseURI string, subscriptionID string) RoutesClient {
+ return RoutesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a route in the specified route table.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+// routeName - the name of the route.
+// routeParameters - parameters supplied to the create or update route operation.
+func (client RoutesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, routeTableName string, routeName string, routeParameters Route) (result RoutesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RoutesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, routeTableName, routeName, routeParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client RoutesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, routeTableName string, routeName string, routeParameters Route) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeName": autorest.Encode("path", routeName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}/routes/{routeName}", pathParameters),
+ autorest.WithJSON(routeParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client RoutesClient) CreateOrUpdateSender(req *http.Request) (future RoutesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RoutesClient) (r Route, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RoutesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ r.Response.Response, err = future.GetResult(sender)
+ if r.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && r.Response.Response.StatusCode != http.StatusNoContent {
+ r, err = client.CreateOrUpdateResponder(r.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesCreateOrUpdateFuture", "Result", r.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client RoutesClient) CreateOrUpdateResponder(resp *http.Response) (result Route, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified route from a route table.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+// routeName - the name of the route.
+func (client RoutesClient) Delete(ctx context.Context, resourceGroupName string, routeTableName string, routeName string) (result RoutesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RoutesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, routeTableName, routeName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client RoutesClient) DeletePreparer(ctx context.Context, resourceGroupName string, routeTableName string, routeName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeName": autorest.Encode("path", routeName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}/routes/{routeName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client RoutesClient) DeleteSender(req *http.Request) (future RoutesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RoutesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RoutesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client RoutesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified route from a route table.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+// routeName - the name of the route.
+func (client RoutesClient) Get(ctx context.Context, resourceGroupName string, routeTableName string, routeName string) (result Route, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RoutesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, routeTableName, routeName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client RoutesClient) GetPreparer(ctx context.Context, resourceGroupName string, routeTableName string, routeName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeName": autorest.Encode("path", routeName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}/routes/{routeName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client RoutesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client RoutesClient) GetResponder(resp *http.Response) (result Route, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all routes in a route table.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+func (client RoutesClient) List(ctx context.Context, resourceGroupName string, routeTableName string) (result RouteListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RoutesClient.List")
+ defer func() {
+ sc := -1
+ if result.rlr.Response.Response != nil {
+ sc = result.rlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, routeTableName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.rlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.rlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.rlr.hasNextLink() && result.rlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client RoutesClient) ListPreparer(ctx context.Context, resourceGroupName string, routeTableName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}/routes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client RoutesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client RoutesClient) ListResponder(resp *http.Response) (result RouteListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client RoutesClient) listNextResults(ctx context.Context, lastResults RouteListResult) (result RouteListResult, err error) {
+ req, err := lastResults.routeListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.RoutesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.RoutesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RoutesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client RoutesClient) ListComplete(ctx context.Context, resourceGroupName string, routeTableName string) (result RouteListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RoutesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, routeTableName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routetables.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routetables.go
new file mode 100644
index 00000000000..fb8173930fc
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/routetables.go
@@ -0,0 +1,649 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// RouteTablesClient is the network Client
+type RouteTablesClient struct {
+ BaseClient
+}
+
+// NewRouteTablesClient creates an instance of the RouteTablesClient client.
+func NewRouteTablesClient(subscriptionID string) RouteTablesClient {
+ return NewRouteTablesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewRouteTablesClientWithBaseURI creates an instance of the RouteTablesClient client using a custom endpoint. Use
+// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewRouteTablesClientWithBaseURI(baseURI string, subscriptionID string) RouteTablesClient {
+ return RouteTablesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or updates a route table in a specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+// parameters - parameters supplied to the create or update route table operation.
+func (client RouteTablesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, routeTableName string, parameters RouteTable) (result RouteTablesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, routeTableName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client RouteTablesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, routeTableName string, parameters RouteTable) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteTablesClient) CreateOrUpdateSender(req *http.Request) (future RouteTablesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteTablesClient) (rt RouteTable, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteTablesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ rt.Response.Response, err = future.GetResult(sender)
+ if rt.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && rt.Response.Response.StatusCode != http.StatusNoContent {
+ rt, err = client.CreateOrUpdateResponder(rt.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesCreateOrUpdateFuture", "Result", rt.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client RouteTablesClient) CreateOrUpdateResponder(resp *http.Response) (result RouteTable, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified route table.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+func (client RouteTablesClient) Delete(ctx context.Context, resourceGroupName string, routeTableName string) (result RouteTablesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, routeTableName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client RouteTablesClient) DeletePreparer(ctx context.Context, resourceGroupName string, routeTableName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteTablesClient) DeleteSender(req *http.Request) (future RouteTablesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteTablesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteTablesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client RouteTablesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified route table.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+// expand - expands referenced resources.
+func (client RouteTablesClient) Get(ctx context.Context, resourceGroupName string, routeTableName string, expand string) (result RouteTable, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, routeTableName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client RouteTablesClient) GetPreparer(ctx context.Context, resourceGroupName string, routeTableName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteTablesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client RouteTablesClient) GetResponder(resp *http.Response) (result RouteTable, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all route tables in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client RouteTablesClient) List(ctx context.Context, resourceGroupName string) (result RouteTableListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.List")
+ defer func() {
+ sc := -1
+ if result.rtlr.Response.Response != nil {
+ sc = result.rtlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.rtlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.rtlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.rtlr.hasNextLink() && result.rtlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client RouteTablesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteTablesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client RouteTablesClient) ListResponder(resp *http.Response) (result RouteTableListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client RouteTablesClient) listNextResults(ctx context.Context, lastResults RouteTableListResult) (result RouteTableListResult, err error) {
+ req, err := lastResults.routeTableListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.RouteTablesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.RouteTablesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client RouteTablesClient) ListComplete(ctx context.Context, resourceGroupName string) (result RouteTableListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all route tables in a subscription.
+func (client RouteTablesClient) ListAll(ctx context.Context) (result RouteTableListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.rtlr.Response.Response != nil {
+ sc = result.rtlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.rtlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.rtlr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.rtlr.hasNextLink() && result.rtlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client RouteTablesClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/routeTables", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteTablesClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client RouteTablesClient) ListAllResponder(resp *http.Response) (result RouteTableListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client RouteTablesClient) listAllNextResults(ctx context.Context, lastResults RouteTableListResult) (result RouteTableListResult, err error) {
+ req, err := lastResults.routeTableListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.RouteTablesClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.RouteTablesClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client RouteTablesClient) ListAllComplete(ctx context.Context) (result RouteTableListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// UpdateTags updates a route table tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// routeTableName - the name of the route table.
+// parameters - parameters supplied to update route table tags.
+func (client RouteTablesClient) UpdateTags(ctx context.Context, resourceGroupName string, routeTableName string, parameters TagsObject) (result RouteTablesUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/RouteTablesClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, routeTableName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client RouteTablesClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, routeTableName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeTableName": autorest.Encode("path", routeTableName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/routeTables/{routeTableName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client RouteTablesClient) UpdateTagsSender(req *http.Request) (future RouteTablesUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client RouteTablesClient) (rt RouteTable, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.RouteTablesUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ rt.Response.Response, err = future.GetResult(sender)
+ if rt.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && rt.Response.Response.StatusCode != http.StatusNoContent {
+ rt, err = client.UpdateTagsResponder(rt.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.RouteTablesUpdateTagsFuture", "Result", rt.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client RouteTablesClient) UpdateTagsResponder(resp *http.Response) (result RouteTable, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/securitygroups.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/securitygroups.go
new file mode 100644
index 00000000000..4e2f662accf
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/securitygroups.go
@@ -0,0 +1,649 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// SecurityGroupsClient is the network Client
+type SecurityGroupsClient struct {
+ BaseClient
+}
+
+// NewSecurityGroupsClient creates an instance of the SecurityGroupsClient client.
+func NewSecurityGroupsClient(subscriptionID string) SecurityGroupsClient {
+ return NewSecurityGroupsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewSecurityGroupsClientWithBaseURI creates an instance of the SecurityGroupsClient client using a custom endpoint.
+// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewSecurityGroupsClientWithBaseURI(baseURI string, subscriptionID string) SecurityGroupsClient {
+ return SecurityGroupsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a network security group in the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+// parameters - parameters supplied to the create or update network security group operation.
+func (client SecurityGroupsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, parameters SecurityGroup) (result SecurityGroupsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, networkSecurityGroupName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client SecurityGroupsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, parameters SecurityGroup) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityGroupsClient) CreateOrUpdateSender(req *http.Request) (future SecurityGroupsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SecurityGroupsClient) (sg SecurityGroup, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.SecurityGroupsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ sg.Response.Response, err = future.GetResult(sender)
+ if sg.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && sg.Response.Response.StatusCode != http.StatusNoContent {
+ sg, err = client.CreateOrUpdateResponder(sg.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsCreateOrUpdateFuture", "Result", sg.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client SecurityGroupsClient) CreateOrUpdateResponder(resp *http.Response) (result SecurityGroup, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified network security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+func (client SecurityGroupsClient) Delete(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (result SecurityGroupsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, networkSecurityGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client SecurityGroupsClient) DeletePreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityGroupsClient) DeleteSender(req *http.Request) (future SecurityGroupsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SecurityGroupsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.SecurityGroupsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client SecurityGroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified network security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+// expand - expands referenced resources.
+func (client SecurityGroupsClient) Get(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, expand string) (result SecurityGroup, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkSecurityGroupName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client SecurityGroupsClient) GetPreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityGroupsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client SecurityGroupsClient) GetResponder(resp *http.Response) (result SecurityGroup, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all network security groups in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client SecurityGroupsClient) List(ctx context.Context, resourceGroupName string) (result SecurityGroupListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.List")
+ defer func() {
+ sc := -1
+ if result.sglr.Response.Response != nil {
+ sc = result.sglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.sglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.sglr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.sglr.hasNextLink() && result.sglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client SecurityGroupsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityGroupsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client SecurityGroupsClient) ListResponder(resp *http.Response) (result SecurityGroupListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client SecurityGroupsClient) listNextResults(ctx context.Context, lastResults SecurityGroupListResult) (result SecurityGroupListResult, err error) {
+ req, err := lastResults.securityGroupListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client SecurityGroupsClient) ListComplete(ctx context.Context, resourceGroupName string) (result SecurityGroupListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all network security groups in a subscription.
+func (client SecurityGroupsClient) ListAll(ctx context.Context) (result SecurityGroupListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.sglr.Response.Response != nil {
+ sc = result.sglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.sglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.sglr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.sglr.hasNextLink() && result.sglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client SecurityGroupsClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/networkSecurityGroups", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityGroupsClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client SecurityGroupsClient) ListAllResponder(resp *http.Response) (result SecurityGroupListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client SecurityGroupsClient) listAllNextResults(ctx context.Context, lastResults SecurityGroupListResult) (result SecurityGroupListResult, err error) {
+ req, err := lastResults.securityGroupListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client SecurityGroupsClient) ListAllComplete(ctx context.Context) (result SecurityGroupListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// UpdateTags updates a network security group tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+// parameters - parameters supplied to update network security group tags.
+func (client SecurityGroupsClient) UpdateTags(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, parameters TagsObject) (result SecurityGroupsUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityGroupsClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, networkSecurityGroupName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client SecurityGroupsClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityGroupsClient) UpdateTagsSender(req *http.Request) (future SecurityGroupsUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SecurityGroupsClient) (sg SecurityGroup, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.SecurityGroupsUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ sg.Response.Response, err = future.GetResult(sender)
+ if sg.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && sg.Response.Response.StatusCode != http.StatusNoContent {
+ sg, err = client.UpdateTagsResponder(sg.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityGroupsUpdateTagsFuture", "Result", sg.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client SecurityGroupsClient) UpdateTagsResponder(resp *http.Response) (result SecurityGroup, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/securityrules.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/securityrules.go
new file mode 100644
index 00000000000..517d8967a73
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/securityrules.go
@@ -0,0 +1,436 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// SecurityRulesClient is the network Client
+type SecurityRulesClient struct {
+ BaseClient
+}
+
+// NewSecurityRulesClient creates an instance of the SecurityRulesClient client.
+func NewSecurityRulesClient(subscriptionID string) SecurityRulesClient {
+ return NewSecurityRulesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewSecurityRulesClientWithBaseURI creates an instance of the SecurityRulesClient client using a custom endpoint.
+// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewSecurityRulesClientWithBaseURI(baseURI string, subscriptionID string) SecurityRulesClient {
+ return SecurityRulesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a security rule in the specified network security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+// securityRuleName - the name of the security rule.
+// securityRuleParameters - parameters supplied to the create or update network security rule operation.
+func (client SecurityRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, securityRuleName string, securityRuleParameters SecurityRule) (result SecurityRulesCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityRulesClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, networkSecurityGroupName, securityRuleName, securityRuleParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client SecurityRulesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, securityRuleName string, securityRuleParameters SecurityRule) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "securityRuleName": autorest.Encode("path", securityRuleName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}/securityRules/{securityRuleName}", pathParameters),
+ autorest.WithJSON(securityRuleParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityRulesClient) CreateOrUpdateSender(req *http.Request) (future SecurityRulesCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SecurityRulesClient) (sr SecurityRule, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.SecurityRulesCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ sr.Response.Response, err = future.GetResult(sender)
+ if sr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && sr.Response.Response.StatusCode != http.StatusNoContent {
+ sr, err = client.CreateOrUpdateResponder(sr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesCreateOrUpdateFuture", "Result", sr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client SecurityRulesClient) CreateOrUpdateResponder(resp *http.Response) (result SecurityRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified network security rule.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+// securityRuleName - the name of the security rule.
+func (client SecurityRulesClient) Delete(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, securityRuleName string) (result SecurityRulesDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityRulesClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, networkSecurityGroupName, securityRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client SecurityRulesClient) DeletePreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, securityRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "securityRuleName": autorest.Encode("path", securityRuleName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}/securityRules/{securityRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityRulesClient) DeleteSender(req *http.Request) (future SecurityRulesDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SecurityRulesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.SecurityRulesDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client SecurityRulesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get get the specified network security rule.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+// securityRuleName - the name of the security rule.
+func (client SecurityRulesClient) Get(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, securityRuleName string) (result SecurityRule, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityRulesClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkSecurityGroupName, securityRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client SecurityRulesClient) GetPreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string, securityRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "securityRuleName": autorest.Encode("path", securityRuleName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}/securityRules/{securityRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityRulesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client SecurityRulesClient) GetResponder(resp *http.Response) (result SecurityRule, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all security rules in a network security group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkSecurityGroupName - the name of the network security group.
+func (client SecurityRulesClient) List(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (result SecurityRuleListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.srlr.Response.Response != nil {
+ sc = result.srlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, networkSecurityGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.srlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.srlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.srlr.hasNextLink() && result.srlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client SecurityRulesClient) ListPreparer(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkSecurityGroupName": autorest.Encode("path", networkSecurityGroupName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}/securityRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client SecurityRulesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client SecurityRulesClient) ListResponder(resp *http.Response) (result SecurityRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client SecurityRulesClient) listNextResults(ctx context.Context, lastResults SecurityRuleListResult) (result SecurityRuleListResult, err error) {
+ req, err := lastResults.securityRuleListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.SecurityRulesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.SecurityRulesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SecurityRulesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client SecurityRulesClient) ListComplete(ctx context.Context, resourceGroupName string, networkSecurityGroupName string) (result SecurityRuleListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SecurityRulesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, networkSecurityGroupName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/subnets.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/subnets.go
new file mode 100644
index 00000000000..ad32e199d0c
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/subnets.go
@@ -0,0 +1,440 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// SubnetsClient is the network Client
+type SubnetsClient struct {
+ BaseClient
+}
+
+// NewSubnetsClient creates an instance of the SubnetsClient client.
+func NewSubnetsClient(subscriptionID string) SubnetsClient {
+ return NewSubnetsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewSubnetsClientWithBaseURI creates an instance of the SubnetsClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewSubnetsClientWithBaseURI(baseURI string, subscriptionID string) SubnetsClient {
+ return SubnetsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a subnet in the specified virtual network.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// subnetName - the name of the subnet.
+// subnetParameters - parameters supplied to the create or update subnet operation.
+func (client SubnetsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters Subnet) (result SubnetsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SubnetsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkName, subnetName, subnetParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client SubnetsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters Subnet) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subnetName": autorest.Encode("path", subnetName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}", pathParameters),
+ autorest.WithJSON(subnetParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client SubnetsClient) CreateOrUpdateSender(req *http.Request) (future SubnetsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SubnetsClient) (s Subnet, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.SubnetsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ s.Response.Response, err = future.GetResult(sender)
+ if s.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && s.Response.Response.StatusCode != http.StatusNoContent {
+ s, err = client.CreateOrUpdateResponder(s.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsCreateOrUpdateFuture", "Result", s.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client SubnetsClient) CreateOrUpdateResponder(resp *http.Response) (result Subnet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified subnet.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// subnetName - the name of the subnet.
+func (client SubnetsClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string) (result SubnetsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SubnetsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkName, subnetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client SubnetsClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subnetName": autorest.Encode("path", subnetName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client SubnetsClient) DeleteSender(req *http.Request) (future SubnetsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client SubnetsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.SubnetsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client SubnetsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified subnet by virtual network and resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// subnetName - the name of the subnet.
+// expand - expands referenced resources.
+func (client SubnetsClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, expand string) (result Subnet, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SubnetsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkName, subnetName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client SubnetsClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, subnetName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subnetName": autorest.Encode("path", subnetName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client SubnetsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client SubnetsClient) GetResponder(resp *http.Response) (result Subnet, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all subnets in a virtual network.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+func (client SubnetsClient) List(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result SubnetListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SubnetsClient.List")
+ defer func() {
+ sc := -1
+ if result.slr.Response.Response != nil {
+ sc = result.slr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, virtualNetworkName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.slr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.slr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.slr.hasNextLink() && result.slr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client SubnetsClient) ListPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client SubnetsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client SubnetsClient) ListResponder(resp *http.Response) (result SubnetListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client SubnetsClient) listNextResults(ctx context.Context, lastResults SubnetListResult) (result SubnetListResult, err error) {
+ req, err := lastResults.subnetListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.SubnetsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.SubnetsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.SubnetsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client SubnetsClient) ListComplete(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result SubnetListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SubnetsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, virtualNetworkName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/usages.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/usages.go
new file mode 100644
index 00000000000..0ff04aae862
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/usages.go
@@ -0,0 +1,165 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// UsagesClient is the network Client
+type UsagesClient struct {
+ BaseClient
+}
+
+// NewUsagesClient creates an instance of the UsagesClient client.
+func NewUsagesClient(subscriptionID string) UsagesClient {
+ return NewUsagesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewUsagesClientWithBaseURI creates an instance of the UsagesClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewUsagesClientWithBaseURI(baseURI string, subscriptionID string) UsagesClient {
+ return UsagesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List list network usages for a subscription.
+// Parameters:
+// location - the location where resource usage is queried.
+func (client UsagesClient) List(ctx context.Context, location string) (result UsagesListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/UsagesClient.List")
+ defer func() {
+ sc := -1
+ if result.ulr.Response.Response != nil {
+ sc = result.ulr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: location,
+ Constraints: []validation.Constraint{{Target: "location", Name: validation.Pattern, Rule: `^[-\w\._]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.UsagesClient", "List", err.Error())
+ }
+
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, location)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.UsagesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.ulr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.UsagesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.ulr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.UsagesClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.ulr.hasNextLink() && result.ulr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client UsagesClient) ListPreparer(ctx context.Context, location string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "location": autorest.Encode("path", location),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/locations/{location}/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client UsagesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client UsagesClient) ListResponder(resp *http.Response) (result UsagesListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client UsagesClient) listNextResults(ctx context.Context, lastResults UsagesListResult) (result UsagesListResult, err error) {
+ req, err := lastResults.usagesListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.UsagesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.UsagesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.UsagesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client UsagesClient) ListComplete(ctx context.Context, location string) (result UsagesListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/UsagesClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, location)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/version.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/version.go
new file mode 100644
index 00000000000..1c1d1edf694
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/version.go
@@ -0,0 +1,30 @@
+package network
+
+import "github.com/Azure/azure-sdk-for-go/version"
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// UserAgent returns the UserAgent string to use when sending http.Requests.
+func UserAgent() string {
+ return "Azure-SDK-For-Go/" + Version() + " network/2017-10-01"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+ return version.Number
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkgatewayconnections.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkgatewayconnections.go
new file mode 100644
index 00000000000..73818bf8f80
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkgatewayconnections.go
@@ -0,0 +1,854 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualNetworkGatewayConnectionsClient is the network Client
+type VirtualNetworkGatewayConnectionsClient struct {
+ BaseClient
+}
+
+// NewVirtualNetworkGatewayConnectionsClient creates an instance of the VirtualNetworkGatewayConnectionsClient client.
+func NewVirtualNetworkGatewayConnectionsClient(subscriptionID string) VirtualNetworkGatewayConnectionsClient {
+ return NewVirtualNetworkGatewayConnectionsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualNetworkGatewayConnectionsClientWithBaseURI creates an instance of the
+// VirtualNetworkGatewayConnectionsClient client using a custom endpoint. Use this when interacting with an Azure
+// cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewVirtualNetworkGatewayConnectionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworkGatewayConnectionsClient {
+ return VirtualNetworkGatewayConnectionsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a virtual network gateway connection in the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the name of the virtual network gateway connection.
+// parameters - parameters supplied to the create or update virtual network gateway connection operation.
+func (client VirtualNetworkGatewayConnectionsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VirtualNetworkGatewayConnection) (result VirtualNetworkGatewayConnectionsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayConnectionPropertiesFormat", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayConnectionPropertiesFormat.VirtualNetworkGateway1", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayConnectionPropertiesFormat.VirtualNetworkGateway1.VirtualNetworkGatewayPropertiesFormat", Name: validation.Null, Rule: true, Chain: nil}}},
+ {Target: "parameters.VirtualNetworkGatewayConnectionPropertiesFormat.VirtualNetworkGateway2", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayConnectionPropertiesFormat.VirtualNetworkGateway2.VirtualNetworkGatewayPropertiesFormat", Name: validation.Null, Rule: true, Chain: nil}}},
+ {Target: "parameters.VirtualNetworkGatewayConnectionPropertiesFormat.LocalNetworkGateway2", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayConnectionPropertiesFormat.LocalNetworkGateway2.LocalNetworkGatewayPropertiesFormat", Name: validation.Null, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.VirtualNetworkGatewayConnectionsClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualNetworkGatewayConnectionsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VirtualNetworkGatewayConnection) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) CreateOrUpdateSender(req *http.Request) (future VirtualNetworkGatewayConnectionsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewayConnectionsClient) (vngc VirtualNetworkGatewayConnection, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewayConnectionsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vngc.Response.Response, err = future.GetResult(sender)
+ if vngc.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vngc.Response.Response.StatusCode != http.StatusNoContent {
+ vngc, err = client.CreateOrUpdateResponder(vngc.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsCreateOrUpdateFuture", "Result", vngc.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualNetworkGatewayConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified virtual network Gateway connection.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the name of the virtual network gateway connection.
+func (client VirtualNetworkGatewayConnectionsClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string) (result VirtualNetworkGatewayConnectionsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualNetworkGatewayConnectionsClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) DeleteSender(req *http.Request) (future VirtualNetworkGatewayConnectionsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewayConnectionsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewayConnectionsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified virtual network gateway connection by resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the name of the virtual network gateway connection.
+func (client VirtualNetworkGatewayConnectionsClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string) (result VirtualNetworkGatewayConnection, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualNetworkGatewayConnectionsClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) GetResponder(resp *http.Response) (result VirtualNetworkGatewayConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetSharedKey the Get VirtualNetworkGatewayConnectionSharedKey operation retrieves information about the specified
+// virtual network gateway connection shared key through Network resource provider.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the virtual network gateway connection shared key name.
+func (client VirtualNetworkGatewayConnectionsClient) GetSharedKey(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string) (result ConnectionSharedKey, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.GetSharedKey")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetSharedKeyPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "GetSharedKey", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSharedKeySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "GetSharedKey", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetSharedKeyResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "GetSharedKey", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetSharedKeyPreparer prepares the GetSharedKey request.
+func (client VirtualNetworkGatewayConnectionsClient) GetSharedKeyPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/sharedkey", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSharedKeySender sends the GetSharedKey request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) GetSharedKeySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetSharedKeyResponder handles the response to the GetSharedKey request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) GetSharedKeyResponder(resp *http.Response) (result ConnectionSharedKey, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List the List VirtualNetworkGatewayConnections operation retrieves all the virtual network gateways connections
+// created.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client VirtualNetworkGatewayConnectionsClient) List(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayConnectionListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.List")
+ defer func() {
+ sc := -1
+ if result.vngclr.Response.Response != nil {
+ sc = result.vngclr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vngclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vngclr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vngclr.hasNextLink() && result.vngclr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualNetworkGatewayConnectionsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) ListResponder(resp *http.Response) (result VirtualNetworkGatewayConnectionListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualNetworkGatewayConnectionsClient) listNextResults(ctx context.Context, lastResults VirtualNetworkGatewayConnectionListResult) (result VirtualNetworkGatewayConnectionListResult, err error) {
+ req, err := lastResults.virtualNetworkGatewayConnectionListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualNetworkGatewayConnectionsClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayConnectionListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ResetSharedKey the VirtualNetworkGatewayConnectionResetSharedKey operation resets the virtual network gateway
+// connection shared key for passed virtual network gateway connection in the specified resource group through Network
+// resource provider.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the virtual network gateway connection reset shared key Name.
+// parameters - parameters supplied to the begin reset virtual network gateway connection shared key operation
+// through network resource provider.
+func (client VirtualNetworkGatewayConnectionsClient) ResetSharedKey(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters ConnectionResetSharedKey) (result VirtualNetworkGatewayConnectionsResetSharedKeyFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.ResetSharedKey")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.KeyLength", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.KeyLength", Name: validation.InclusiveMaximum, Rule: int64(128), Chain: nil},
+ {Target: "parameters.KeyLength", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.VirtualNetworkGatewayConnectionsClient", "ResetSharedKey", err.Error())
+ }
+
+ req, err := client.ResetSharedKeyPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "ResetSharedKey", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ResetSharedKeySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "ResetSharedKey", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ResetSharedKeyPreparer prepares the ResetSharedKey request.
+func (client VirtualNetworkGatewayConnectionsClient) ResetSharedKeyPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters ConnectionResetSharedKey) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/sharedkey/reset", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ResetSharedKeySender sends the ResetSharedKey request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) ResetSharedKeySender(req *http.Request) (future VirtualNetworkGatewayConnectionsResetSharedKeyFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewayConnectionsClient) (crsk ConnectionResetSharedKey, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsResetSharedKeyFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewayConnectionsResetSharedKeyFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ crsk.Response.Response, err = future.GetResult(sender)
+ if crsk.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsResetSharedKeyFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && crsk.Response.Response.StatusCode != http.StatusNoContent {
+ crsk, err = client.ResetSharedKeyResponder(crsk.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsResetSharedKeyFuture", "Result", crsk.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ResetSharedKeyResponder handles the response to the ResetSharedKey request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) ResetSharedKeyResponder(resp *http.Response) (result ConnectionResetSharedKey, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// SetSharedKey the Put VirtualNetworkGatewayConnectionSharedKey operation sets the virtual network gateway connection
+// shared key for passed virtual network gateway connection in the specified resource group through Network resource
+// provider.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the virtual network gateway connection name.
+// parameters - parameters supplied to the Begin Set Virtual Network Gateway connection Shared key operation
+// throughNetwork resource provider.
+func (client VirtualNetworkGatewayConnectionsClient) SetSharedKey(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters ConnectionSharedKey) (result VirtualNetworkGatewayConnectionsSetSharedKeyFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.SetSharedKey")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.Value", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.VirtualNetworkGatewayConnectionsClient", "SetSharedKey", err.Error())
+ }
+
+ req, err := client.SetSharedKeyPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "SetSharedKey", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.SetSharedKeySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "SetSharedKey", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// SetSharedKeyPreparer prepares the SetSharedKey request.
+func (client VirtualNetworkGatewayConnectionsClient) SetSharedKeyPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters ConnectionSharedKey) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/sharedkey", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// SetSharedKeySender sends the SetSharedKey request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) SetSharedKeySender(req *http.Request) (future VirtualNetworkGatewayConnectionsSetSharedKeyFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewayConnectionsClient) (csk ConnectionSharedKey, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsSetSharedKeyFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewayConnectionsSetSharedKeyFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ csk.Response.Response, err = future.GetResult(sender)
+ if csk.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsSetSharedKeyFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && csk.Response.Response.StatusCode != http.StatusNoContent {
+ csk, err = client.SetSharedKeyResponder(csk.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsSetSharedKeyFuture", "Result", csk.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// SetSharedKeyResponder handles the response to the SetSharedKey request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) SetSharedKeyResponder(resp *http.Response) (result ConnectionSharedKey, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateTags updates a virtual network gateway connection tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the name of the virtual network gateway connection.
+// parameters - parameters supplied to update virtual network gateway connection tags.
+func (client VirtualNetworkGatewayConnectionsClient) UpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters TagsObject) (result VirtualNetworkGatewayConnectionsUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewayConnectionsClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client VirtualNetworkGatewayConnectionsClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewayConnectionsClient) UpdateTagsSender(req *http.Request) (future VirtualNetworkGatewayConnectionsUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewayConnectionsClient) (vngcle VirtualNetworkGatewayConnectionListEntity, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewayConnectionsUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vngcle.Response.Response, err = future.GetResult(sender)
+ if vngcle.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vngcle.Response.Response.StatusCode != http.StatusNoContent {
+ vngcle, err = client.UpdateTagsResponder(vngcle.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewayConnectionsUpdateTagsFuture", "Result", vngcle.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewayConnectionsClient) UpdateTagsResponder(resp *http.Response) (result VirtualNetworkGatewayConnectionListEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkgateways.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkgateways.go
new file mode 100644
index 00000000000..4da2cbb8417
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkgateways.go
@@ -0,0 +1,1543 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualNetworkGatewaysClient is the network Client
+type VirtualNetworkGatewaysClient struct {
+ BaseClient
+}
+
+// NewVirtualNetworkGatewaysClient creates an instance of the VirtualNetworkGatewaysClient client.
+func NewVirtualNetworkGatewaysClient(subscriptionID string) VirtualNetworkGatewaysClient {
+ return NewVirtualNetworkGatewaysClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualNetworkGatewaysClientWithBaseURI creates an instance of the VirtualNetworkGatewaysClient client using a
+// custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds,
+// Azure stack).
+func NewVirtualNetworkGatewaysClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworkGatewaysClient {
+ return VirtualNetworkGatewaysClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a virtual network gateway in the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+// parameters - parameters supplied to create or update virtual network gateway operation.
+func (client VirtualNetworkGatewaysClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway) (result VirtualNetworkGatewaysCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayPropertiesFormat", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.VirtualNetworkGatewaysClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualNetworkGatewaysClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) CreateOrUpdateSender(req *http.Request) (future VirtualNetworkGatewaysCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vng.Response.Response, err = future.GetResult(sender)
+ if vng.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent {
+ vng, err = client.CreateOrUpdateResponder(vng.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", vng.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualNetworkGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified virtual network gateway.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+func (client VirtualNetworkGatewaysClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualNetworkGatewaysClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) DeleteSender(req *http.Request) (future VirtualNetworkGatewaysDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Generatevpnclientpackage generates VPN client package for P2S client of the virtual network gateway in the specified
+// resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+// parameters - parameters supplied to the generate virtual network gateway VPN client package operation.
+func (client VirtualNetworkGatewaysClient) Generatevpnclientpackage(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (result VirtualNetworkGatewaysGeneratevpnclientpackageFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Generatevpnclientpackage")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GeneratevpnclientpackagePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Generatevpnclientpackage", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GeneratevpnclientpackageSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Generatevpnclientpackage", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GeneratevpnclientpackagePreparer prepares the Generatevpnclientpackage request.
+func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackagePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnclientpackage", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GeneratevpnclientpackageSender sends the Generatevpnclientpackage request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackageSender(req *http.Request) (future VirtualNetworkGatewaysGeneratevpnclientpackageFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ s.Response.Response, err = future.GetResult(sender)
+ if s.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && s.Response.Response.StatusCode != http.StatusNoContent {
+ s, err = client.GeneratevpnclientpackageResponder(s.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", s.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GeneratevpnclientpackageResponder handles the response to the Generatevpnclientpackage request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackageResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GenerateVpnProfile generates VPN profile for P2S client of the virtual network gateway in the specified resource
+// group. Used for IKEV2 and radius based authentication.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+// parameters - parameters supplied to the generate virtual network gateway VPN client package operation.
+func (client VirtualNetworkGatewaysClient) GenerateVpnProfile(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (result VirtualNetworkGatewaysGenerateVpnProfileFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GenerateVpnProfile")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GenerateVpnProfilePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GenerateVpnProfile", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GenerateVpnProfileSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GenerateVpnProfile", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GenerateVpnProfilePreparer prepares the GenerateVpnProfile request.
+func (client VirtualNetworkGatewaysClient) GenerateVpnProfilePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnprofile", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GenerateVpnProfileSender sends the GenerateVpnProfile request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) GenerateVpnProfileSender(req *http.Request) (future VirtualNetworkGatewaysGenerateVpnProfileFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGenerateVpnProfileFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ s.Response.Response, err = future.GetResult(sender)
+ if s.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && s.Response.Response.StatusCode != http.StatusNoContent {
+ s, err = client.GenerateVpnProfileResponder(s.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", s.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GenerateVpnProfileResponder handles the response to the GenerateVpnProfile request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) GenerateVpnProfileResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Get gets the specified virtual network gateway by resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+func (client VirtualNetworkGatewaysClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGateway, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualNetworkGatewaysClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) GetResponder(resp *http.Response) (result VirtualNetworkGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetAdvertisedRoutes this operation retrieves a list of routes the virtual network gateway is advertising to the
+// specified peer.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+// peer - the IP address of the peer
+func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (result VirtualNetworkGatewaysGetAdvertisedRoutesFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetAdvertisedRoutes")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetAdvertisedRoutesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, peer)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetAdvertisedRoutes", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetAdvertisedRoutesSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetAdvertisedRoutes", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetAdvertisedRoutesPreparer prepares the GetAdvertisedRoutes request.
+func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ "peer": autorest.Encode("query", peer),
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getAdvertisedRoutes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetAdvertisedRoutesSender sends the GetAdvertisedRoutes request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesSender(req *http.Request) (future VirtualNetworkGatewaysGetAdvertisedRoutesFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (grlr GatewayRouteListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ grlr.Response.Response, err = future.GetResult(sender)
+ if grlr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && grlr.Response.Response.StatusCode != http.StatusNoContent {
+ grlr, err = client.GetAdvertisedRoutesResponder(grlr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", grlr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetAdvertisedRoutesResponder handles the response to the GetAdvertisedRoutes request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesResponder(resp *http.Response) (result GatewayRouteListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetBgpPeerStatus the GetBgpPeerStatus operation retrieves the status of all BGP peers.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+// peer - the IP address of the peer to retrieve the status of.
+func (client VirtualNetworkGatewaysClient) GetBgpPeerStatus(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (result VirtualNetworkGatewaysGetBgpPeerStatusFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetBgpPeerStatus")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetBgpPeerStatusPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, peer)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetBgpPeerStatus", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetBgpPeerStatusSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetBgpPeerStatus", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetBgpPeerStatusPreparer prepares the GetBgpPeerStatus request.
+func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(peer) > 0 {
+ queryParameters["peer"] = autorest.Encode("query", peer)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getBgpPeerStatus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetBgpPeerStatusSender sends the GetBgpPeerStatus request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusSender(req *http.Request) (future VirtualNetworkGatewaysGetBgpPeerStatusFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (bpslr BgpPeerStatusListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetBgpPeerStatusFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ bpslr.Response.Response, err = future.GetResult(sender)
+ if bpslr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && bpslr.Response.Response.StatusCode != http.StatusNoContent {
+ bpslr, err = client.GetBgpPeerStatusResponder(bpslr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", bpslr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetBgpPeerStatusResponder handles the response to the GetBgpPeerStatus request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusResponder(resp *http.Response) (result BgpPeerStatusListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetLearnedRoutes this operation retrieves a list of routes the virtual network gateway has learned, including routes
+// learned from BGP peers.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+func (client VirtualNetworkGatewaysClient) GetLearnedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetLearnedRoutesFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetLearnedRoutes")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetLearnedRoutesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetLearnedRoutes", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetLearnedRoutesSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetLearnedRoutes", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetLearnedRoutesPreparer prepares the GetLearnedRoutes request.
+func (client VirtualNetworkGatewaysClient) GetLearnedRoutesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getLearnedRoutes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetLearnedRoutesSender sends the GetLearnedRoutes request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) GetLearnedRoutesSender(req *http.Request) (future VirtualNetworkGatewaysGetLearnedRoutesFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (grlr GatewayRouteListResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetLearnedRoutesFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ grlr.Response.Response, err = future.GetResult(sender)
+ if grlr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && grlr.Response.Response.StatusCode != http.StatusNoContent {
+ grlr, err = client.GetLearnedRoutesResponder(grlr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", grlr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetLearnedRoutesResponder handles the response to the GetLearnedRoutes request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) GetLearnedRoutesResponder(resp *http.Response) (result GatewayRouteListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVpnProfilePackageURL gets pre-generated VPN profile for P2S client of the virtual network gateway in the
+// specified resource group. The profile needs to be generated first using generateVpnProfile.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURL(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetVpnProfilePackageURLFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetVpnProfilePackageURL")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetVpnProfilePackageURLPreparer(ctx, resourceGroupName, virtualNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnProfilePackageURL", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetVpnProfilePackageURLSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnProfilePackageURL", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetVpnProfilePackageURLPreparer prepares the GetVpnProfilePackageURL request.
+func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getvpnprofilepackageurl", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetVpnProfilePackageURLSender sends the GetVpnProfilePackageURL request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLSender(req *http.Request) (future VirtualNetworkGatewaysGetVpnProfilePackageURLFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ s.Response.Response, err = future.GetResult(sender)
+ if s.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && s.Response.Response.StatusCode != http.StatusNoContent {
+ s, err = client.GetVpnProfilePackageURLResponder(s.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", s.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetVpnProfilePackageURLResponder handles the response to the GetVpnProfilePackageURL request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all virtual network gateways by resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client VirtualNetworkGatewaysClient) List(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.List")
+ defer func() {
+ sc := -1
+ if result.vnglr.Response.Response != nil {
+ sc = result.vnglr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vnglr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vnglr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vnglr.hasNextLink() && result.vnglr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualNetworkGatewaysClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) ListResponder(resp *http.Response) (result VirtualNetworkGatewayListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualNetworkGatewaysClient) listNextResults(ctx context.Context, lastResults VirtualNetworkGatewayListResult) (result VirtualNetworkGatewayListResult, err error) {
+ req, err := lastResults.virtualNetworkGatewayListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualNetworkGatewaysClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListConnections gets all the connections in a virtual network gateway.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+func (client VirtualNetworkGatewaysClient) ListConnections(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewayListConnectionsResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ListConnections")
+ defer func() {
+ sc := -1
+ if result.vnglcr.Response.Response != nil {
+ sc = result.vnglcr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listConnectionsNextResults
+ req, err := client.ListConnectionsPreparer(ctx, resourceGroupName, virtualNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListConnectionsSender(req)
+ if err != nil {
+ result.vnglcr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", resp, "Failure sending request")
+ return
+ }
+
+ result.vnglcr, err = client.ListConnectionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", resp, "Failure responding to request")
+ return
+ }
+ if result.vnglcr.hasNextLink() && result.vnglcr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListConnectionsPreparer prepares the ListConnections request.
+func (client VirtualNetworkGatewaysClient) ListConnectionsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/connections", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListConnectionsSender sends the ListConnections request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) ListConnectionsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListConnectionsResponder handles the response to the ListConnections request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) ListConnectionsResponder(resp *http.Response) (result VirtualNetworkGatewayListConnectionsResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listConnectionsNextResults retrieves the next set of results, if any.
+func (client VirtualNetworkGatewaysClient) listConnectionsNextResults(ctx context.Context, lastResults VirtualNetworkGatewayListConnectionsResult) (result VirtualNetworkGatewayListConnectionsResult, err error) {
+ req, err := lastResults.virtualNetworkGatewayListConnectionsResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListConnectionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListConnectionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListConnectionsComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualNetworkGatewaysClient) ListConnectionsComplete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewayListConnectionsResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ListConnections")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListConnections(ctx, resourceGroupName, virtualNetworkGatewayName)
+ return
+}
+
+// Reset resets the primary of the virtual network gateway in the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+// gatewayVip - virtual network gateway vip address supplied to the begin reset of the active-active feature
+// enabled gateway.
+func (client VirtualNetworkGatewaysClient) Reset(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, gatewayVip string) (result VirtualNetworkGatewaysResetFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Reset")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ResetPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, gatewayVip)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Reset", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ResetSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Reset", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ResetPreparer prepares the Reset request.
+func (client VirtualNetworkGatewaysClient) ResetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, gatewayVip string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(gatewayVip) > 0 {
+ queryParameters["gatewayVip"] = autorest.Encode("query", gatewayVip)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/reset", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ResetSender sends the Reset request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) ResetSender(req *http.Request) (future VirtualNetworkGatewaysResetFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysResetFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vng.Response.Response, err = future.GetResult(sender)
+ if vng.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent {
+ vng, err = client.ResetResponder(vng.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", vng.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ResetResponder handles the response to the Reset request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) ResetResponder(resp *http.Response) (result VirtualNetworkGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// SupportedVpnDevices gets a xml format representation for supported vpn devices.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+func (client VirtualNetworkGatewaysClient) SupportedVpnDevices(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result String, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.SupportedVpnDevices")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.SupportedVpnDevicesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SupportedVpnDevicesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SupportedVpnDevicesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// SupportedVpnDevicesPreparer prepares the SupportedVpnDevices request.
+func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/supportedvpndevices", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// SupportedVpnDevicesSender sends the SupportedVpnDevices request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// SupportedVpnDevicesResponder handles the response to the SupportedVpnDevices request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateTags updates a virtual network gateway tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayName - the name of the virtual network gateway.
+// parameters - parameters supplied to update virtual network gateway tags.
+func (client VirtualNetworkGatewaysClient) UpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject) (result VirtualNetworkGatewaysUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client VirtualNetworkGatewaysClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) UpdateTagsSender(req *http.Request) (future VirtualNetworkGatewaysUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vng.Response.Response, err = future.GetResult(sender)
+ if vng.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent {
+ vng, err = client.UpdateTagsResponder(vng.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", vng.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) UpdateTagsResponder(resp *http.Response) (result VirtualNetworkGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// VpnDeviceConfigurationScript gets a xml format representation for vpn device configuration script.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkGatewayConnectionName - the name of the virtual network gateway connection for which the
+// configuration script is generated.
+// parameters - parameters supplied to the generate vpn device script operation.
+func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScript(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VpnDeviceScriptParameters) (result String, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.VpnDeviceConfigurationScript")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.VpnDeviceConfigurationScriptPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.VpnDeviceConfigurationScriptSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.VpnDeviceConfigurationScriptResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// VpnDeviceConfigurationScriptPreparer prepares the VpnDeviceConfigurationScript request.
+func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VpnDeviceScriptParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/vpndeviceconfigurationscript", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// VpnDeviceConfigurationScriptSender sends the VpnDeviceConfigurationScript request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// VpnDeviceConfigurationScriptResponder handles the response to the VpnDeviceConfigurationScript request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkpeerings.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkpeerings.go
new file mode 100644
index 00000000000..e180a3bcc8c
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworkpeerings.go
@@ -0,0 +1,438 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualNetworkPeeringsClient is the network Client
+type VirtualNetworkPeeringsClient struct {
+ BaseClient
+}
+
+// NewVirtualNetworkPeeringsClient creates an instance of the VirtualNetworkPeeringsClient client.
+func NewVirtualNetworkPeeringsClient(subscriptionID string) VirtualNetworkPeeringsClient {
+ return NewVirtualNetworkPeeringsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualNetworkPeeringsClientWithBaseURI creates an instance of the VirtualNetworkPeeringsClient client using a
+// custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds,
+// Azure stack).
+func NewVirtualNetworkPeeringsClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworkPeeringsClient {
+ return VirtualNetworkPeeringsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a peering in the specified virtual network.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// virtualNetworkPeeringName - the name of the peering.
+// virtualNetworkPeeringParameters - parameters supplied to the create or update virtual network peering
+// operation.
+func (client VirtualNetworkPeeringsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, virtualNetworkPeeringName string, virtualNetworkPeeringParameters VirtualNetworkPeering) (result VirtualNetworkPeeringsCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkPeeringsClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualNetworkPeeringsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, virtualNetworkPeeringName string, virtualNetworkPeeringParameters VirtualNetworkPeering) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ "virtualNetworkPeeringName": autorest.Encode("path", virtualNetworkPeeringName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/virtualNetworkPeerings/{virtualNetworkPeeringName}", pathParameters),
+ autorest.WithJSON(virtualNetworkPeeringParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkPeeringsClient) CreateOrUpdateSender(req *http.Request) (future VirtualNetworkPeeringsCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkPeeringsClient) (vnp VirtualNetworkPeering, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkPeeringsCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vnp.Response.Response, err = future.GetResult(sender)
+ if vnp.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vnp.Response.Response.StatusCode != http.StatusNoContent {
+ vnp, err = client.CreateOrUpdateResponder(vnp.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsCreateOrUpdateFuture", "Result", vnp.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkPeeringsClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualNetworkPeering, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified virtual network peering.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// virtualNetworkPeeringName - the name of the virtual network peering.
+func (client VirtualNetworkPeeringsClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkName string, virtualNetworkPeeringName string) (result VirtualNetworkPeeringsDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkPeeringsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkName, virtualNetworkPeeringName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualNetworkPeeringsClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, virtualNetworkPeeringName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ "virtualNetworkPeeringName": autorest.Encode("path", virtualNetworkPeeringName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/virtualNetworkPeerings/{virtualNetworkPeeringName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkPeeringsClient) DeleteSender(req *http.Request) (future VirtualNetworkPeeringsDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworkPeeringsClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkPeeringsDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkPeeringsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified virtual network peering.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// virtualNetworkPeeringName - the name of the virtual network peering.
+func (client VirtualNetworkPeeringsClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkName string, virtualNetworkPeeringName string) (result VirtualNetworkPeering, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkPeeringsClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkName, virtualNetworkPeeringName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualNetworkPeeringsClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, virtualNetworkPeeringName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ "virtualNetworkPeeringName": autorest.Encode("path", virtualNetworkPeeringName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/virtualNetworkPeerings/{virtualNetworkPeeringName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkPeeringsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkPeeringsClient) GetResponder(resp *http.Response) (result VirtualNetworkPeering, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all virtual network peerings in a virtual network.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+func (client VirtualNetworkPeeringsClient) List(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworkPeeringListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkPeeringsClient.List")
+ defer func() {
+ sc := -1
+ if result.vnplr.Response.Response != nil {
+ sc = result.vnplr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName, virtualNetworkName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vnplr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vnplr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vnplr.hasNextLink() && result.vnplr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualNetworkPeeringsClient) ListPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/virtualNetworkPeerings", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworkPeeringsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworkPeeringsClient) ListResponder(resp *http.Response) (result VirtualNetworkPeeringListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualNetworkPeeringsClient) listNextResults(ctx context.Context, lastResults VirtualNetworkPeeringListResult) (result VirtualNetworkPeeringListResult, err error) {
+ req, err := lastResults.virtualNetworkPeeringListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworkPeeringsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualNetworkPeeringsClient) ListComplete(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworkPeeringListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkPeeringsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName, virtualNetworkName)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworks.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworks.go
new file mode 100644
index 00000000000..a8c0b7b2bd7
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/virtualnetworks.go
@@ -0,0 +1,847 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// VirtualNetworksClient is the network Client
+type VirtualNetworksClient struct {
+ BaseClient
+}
+
+// NewVirtualNetworksClient creates an instance of the VirtualNetworksClient client.
+func NewVirtualNetworksClient(subscriptionID string) VirtualNetworksClient {
+ return NewVirtualNetworksClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewVirtualNetworksClientWithBaseURI creates an instance of the VirtualNetworksClient client using a custom endpoint.
+// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewVirtualNetworksClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworksClient {
+ return VirtualNetworksClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CheckIPAddressAvailability checks whether a private IP address is available for use.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// IPAddress - the private IP address to be verified.
+func (client VirtualNetworksClient) CheckIPAddressAvailability(ctx context.Context, resourceGroupName string, virtualNetworkName string, IPAddress string) (result IPAddressAvailabilityResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.CheckIPAddressAvailability")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CheckIPAddressAvailabilityPreparer(ctx, resourceGroupName, virtualNetworkName, IPAddress)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CheckIPAddressAvailability", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CheckIPAddressAvailabilitySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CheckIPAddressAvailability", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CheckIPAddressAvailabilityResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CheckIPAddressAvailability", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// CheckIPAddressAvailabilityPreparer prepares the CheckIPAddressAvailability request.
+func (client VirtualNetworksClient) CheckIPAddressAvailabilityPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, IPAddress string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(IPAddress) > 0 {
+ queryParameters["ipAddress"] = autorest.Encode("query", IPAddress)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/CheckIPAddressAvailability", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CheckIPAddressAvailabilitySender sends the CheckIPAddressAvailability request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) CheckIPAddressAvailabilitySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// CheckIPAddressAvailabilityResponder handles the response to the CheckIPAddressAvailability request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) CheckIPAddressAvailabilityResponder(resp *http.Response) (result IPAddressAvailabilityResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdate creates or updates a virtual network in the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// parameters - parameters supplied to the create or update virtual network operation
+func (client VirtualNetworksClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters VirtualNetwork) (result VirtualNetworksCreateOrUpdateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CreateOrUpdate", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client VirtualNetworksClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters VirtualNetwork) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) CreateOrUpdateSender(req *http.Request) (future VirtualNetworksCreateOrUpdateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworksClient) (vn VirtualNetwork, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworksCreateOrUpdateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vn.Response.Response, err = future.GetResult(sender)
+ if vn.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksCreateOrUpdateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vn.Response.Response.StatusCode != http.StatusNoContent {
+ vn, err = client.CreateOrUpdateResponder(vn.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksCreateOrUpdateFuture", "Result", vn.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualNetwork, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified virtual network.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+func (client VirtualNetworksClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworksDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client VirtualNetworksClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) DeleteSender(req *http.Request) (future VirtualNetworksDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworksClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworksDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified virtual network by resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// expand - expands referenced resources.
+func (client VirtualNetworksClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkName string, expand string) (result VirtualNetwork, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkName, expand)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client VirtualNetworksClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, expand string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(expand) > 0 {
+ queryParameters["$expand"] = autorest.Encode("query", expand)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) GetResponder(resp *http.Response) (result VirtualNetwork, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all virtual networks in a resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client VirtualNetworksClient) List(ctx context.Context, resourceGroupName string) (result VirtualNetworkListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.List")
+ defer func() {
+ sc := -1
+ if result.vnlr.Response.Response != nil {
+ sc = result.vnlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.vnlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.vnlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "List", resp, "Failure responding to request")
+ return
+ }
+ if result.vnlr.hasNextLink() && result.vnlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client VirtualNetworksClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) ListResponder(resp *http.Response) (result VirtualNetworkListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client VirtualNetworksClient) listNextResults(ctx context.Context, lastResults VirtualNetworkListResult) (result VirtualNetworkListResult, err error) {
+ req, err := lastResults.virtualNetworkListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualNetworksClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualNetworkListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.List")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.List(ctx, resourceGroupName)
+ return
+}
+
+// ListAll gets all virtual networks in a subscription.
+func (client VirtualNetworksClient) ListAll(ctx context.Context) (result VirtualNetworkListResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.vnlr.Response.Response != nil {
+ sc = result.vnlr.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listAllNextResults
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.vnlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result.vnlr, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+ if result.vnlr.hasNextLink() && result.vnlr.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client VirtualNetworksClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/virtualNetworks", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) ListAllResponder(resp *http.Response) (result VirtualNetworkListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAllNextResults retrieves the next set of results, if any.
+func (client VirtualNetworksClient) listAllNextResults(ctx context.Context, lastResults VirtualNetworkListResult) (result VirtualNetworkListResult, err error) {
+ req, err := lastResults.virtualNetworkListResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listAllNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listAllNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listAllNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAllComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualNetworksClient) ListAllComplete(ctx context.Context) (result VirtualNetworkListResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListAll(ctx)
+ return
+}
+
+// ListUsage lists usage stats.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+func (client VirtualNetworksClient) ListUsage(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworkListUsageResultPage, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListUsage")
+ defer func() {
+ sc := -1
+ if result.vnlur.Response.Response != nil {
+ sc = result.vnlur.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.fn = client.listUsageNextResults
+ req, err := client.ListUsagePreparer(ctx, resourceGroupName, virtualNetworkName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListUsage", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListUsageSender(req)
+ if err != nil {
+ result.vnlur.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListUsage", resp, "Failure sending request")
+ return
+ }
+
+ result.vnlur, err = client.ListUsageResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListUsage", resp, "Failure responding to request")
+ return
+ }
+ if result.vnlur.hasNextLink() && result.vnlur.IsEmpty() {
+ err = result.NextWithContext(ctx)
+ return
+ }
+
+ return
+}
+
+// ListUsagePreparer prepares the ListUsage request.
+func (client VirtualNetworksClient) ListUsagePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListUsageSender sends the ListUsage request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) ListUsageSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListUsageResponder handles the response to the ListUsage request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) ListUsageResponder(resp *http.Response) (result VirtualNetworkListUsageResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listUsageNextResults retrieves the next set of results, if any.
+func (client VirtualNetworksClient) listUsageNextResults(ctx context.Context, lastResults VirtualNetworkListUsageResult) (result VirtualNetworkListUsageResult, err error) {
+ req, err := lastResults.virtualNetworkListUsageResultPreparer(ctx)
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listUsageNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListUsageSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listUsageNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListUsageResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listUsageNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListUsageComplete enumerates all values, automatically crossing page boundaries as required.
+func (client VirtualNetworksClient) ListUsageComplete(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworkListUsageResultIterator, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListUsage")
+ defer func() {
+ sc := -1
+ if result.Response().Response.Response != nil {
+ sc = result.page.Response().Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ result.page, err = client.ListUsage(ctx, resourceGroupName, virtualNetworkName)
+ return
+}
+
+// UpdateTags updates a virtual network tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// virtualNetworkName - the name of the virtual network.
+// parameters - parameters supplied to update virtual network tags.
+func (client VirtualNetworksClient) UpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters TagsObject) (result VirtualNetworksUpdateTagsFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, virtualNetworkName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.UpdateTagsSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "UpdateTags", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client VirtualNetworksClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "virtualNetworkName": autorest.Encode("path", virtualNetworkName),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client VirtualNetworksClient) UpdateTagsSender(req *http.Request) (future VirtualNetworksUpdateTagsFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client VirtualNetworksClient) (vn VirtualNetwork, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksUpdateTagsFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.VirtualNetworksUpdateTagsFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vn.Response.Response, err = future.GetResult(sender)
+ if vn.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksUpdateTagsFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vn.Response.Response.StatusCode != http.StatusNoContent {
+ vn, err = client.UpdateTagsResponder(vn.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.VirtualNetworksUpdateTagsFuture", "Result", vn.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client VirtualNetworksClient) UpdateTagsResponder(resp *http.Response) (result VirtualNetwork, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/watchers.go b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/watchers.go
new file mode 100644
index 00000000000..770f5054efd
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network/watchers.go
@@ -0,0 +1,1706 @@
+package network
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// WatchersClient is the network Client
+type WatchersClient struct {
+ BaseClient
+}
+
+// NewWatchersClient creates an instance of the WatchersClient client.
+func NewWatchersClient(subscriptionID string) WatchersClient {
+ return NewWatchersClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWatchersClientWithBaseURI creates an instance of the WatchersClient client using a custom endpoint. Use this
+// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewWatchersClientWithBaseURI(baseURI string, subscriptionID string) WatchersClient {
+ return WatchersClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CheckConnectivity verifies the possibility of establishing a direct TCP connection from a virtual machine to a given
+// endpoint including another VM or an arbitrary remote server.
+// Parameters:
+// resourceGroupName - the name of the network watcher resource group.
+// networkWatcherName - the name of the network watcher resource.
+// parameters - parameters that determine how the connectivity check will be performed.
+func (client WatchersClient) CheckConnectivity(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters ConnectivityParameters) (result WatchersCheckConnectivityFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.CheckConnectivity")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.Source", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.Source.ResourceID", Name: validation.Null, Rule: true, Chain: nil}}},
+ {Target: "parameters.Destination", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "CheckConnectivity", err.Error())
+ }
+
+ req, err := client.CheckConnectivityPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "CheckConnectivity", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CheckConnectivitySender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "CheckConnectivity", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CheckConnectivityPreparer prepares the CheckConnectivity request.
+func (client WatchersClient) CheckConnectivityPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters ConnectivityParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/connectivityCheck", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CheckConnectivitySender sends the CheckConnectivity request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) CheckConnectivitySender(req *http.Request) (future WatchersCheckConnectivityFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (ci ConnectivityInformation, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersCheckConnectivityFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersCheckConnectivityFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ ci.Response.Response, err = future.GetResult(sender)
+ if ci.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersCheckConnectivityFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && ci.Response.Response.StatusCode != http.StatusNoContent {
+ ci, err = client.CheckConnectivityResponder(ci.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersCheckConnectivityFuture", "Result", ci.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CheckConnectivityResponder handles the response to the CheckConnectivity request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) CheckConnectivityResponder(resp *http.Response) (result ConnectivityInformation, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdate creates or updates a network watcher in the specified resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// parameters - parameters that define the network watcher resource.
+func (client WatchersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters Watcher) (result Watcher, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.CreateOrUpdate")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "CreateOrUpdate", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client WatchersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters Watcher) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) CreateOrUpdateResponder(resp *http.Response) (result Watcher, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes the specified network watcher resource.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+func (client WatchersClient) Delete(ctx context.Context, resourceGroupName string, networkWatcherName string) (result WatchersDeleteFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.DeletePreparer(ctx, resourceGroupName, networkWatcherName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "Delete", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client WatchersClient) DeletePreparer(ctx context.Context, resourceGroupName string, networkWatcherName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) DeleteSender(req *http.Request) (future WatchersDeleteFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersDeleteFuture")
+ return
+ }
+ ar.Response = future.Response()
+ return
+ }
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the specified network watcher by resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+func (client WatchersClient) Get(ctx context.Context, resourceGroupName string, networkWatcherName string) (result Watcher, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.Get")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetPreparer(ctx, resourceGroupName, networkWatcherName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "Get", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client WatchersClient) GetPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetResponder(resp *http.Response) (result Watcher, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetAzureReachabilityReport gets the relative latency score for internet service providers from a specified location
+// to Azure regions.
+// Parameters:
+// resourceGroupName - the name of the network watcher resource group.
+// networkWatcherName - the name of the network watcher resource.
+// parameters - parameters that determine Azure reachability report configuration.
+func (client WatchersClient) GetAzureReachabilityReport(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters AzureReachabilityReportParameters) (result WatchersGetAzureReachabilityReportFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.GetAzureReachabilityReport")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.ProviderLocation", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.ProviderLocation.Country", Name: validation.Null, Rule: true, Chain: nil}}},
+ {Target: "parameters.StartTime", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.EndTime", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "GetAzureReachabilityReport", err.Error())
+ }
+
+ req, err := client.GetAzureReachabilityReportPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetAzureReachabilityReport", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetAzureReachabilityReportSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetAzureReachabilityReport", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetAzureReachabilityReportPreparer prepares the GetAzureReachabilityReport request.
+func (client WatchersClient) GetAzureReachabilityReportPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters AzureReachabilityReportParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/azureReachabilityReport", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetAzureReachabilityReportSender sends the GetAzureReachabilityReport request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetAzureReachabilityReportSender(req *http.Request) (future WatchersGetAzureReachabilityReportFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (arr AzureReachabilityReport, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetAzureReachabilityReportFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersGetAzureReachabilityReportFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ arr.Response.Response, err = future.GetResult(sender)
+ if arr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetAzureReachabilityReportFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && arr.Response.Response.StatusCode != http.StatusNoContent {
+ arr, err = client.GetAzureReachabilityReportResponder(arr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetAzureReachabilityReportFuture", "Result", arr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetAzureReachabilityReportResponder handles the response to the GetAzureReachabilityReport request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetAzureReachabilityReportResponder(resp *http.Response) (result AzureReachabilityReport, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetFlowLogStatus queries status of flow log on a specified resource.
+// Parameters:
+// resourceGroupName - the name of the network watcher resource group.
+// networkWatcherName - the name of the network watcher resource.
+// parameters - parameters that define a resource to query flow log status.
+func (client WatchersClient) GetFlowLogStatus(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters FlowLogStatusParameters) (result WatchersGetFlowLogStatusFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.GetFlowLogStatus")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.TargetResourceID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "GetFlowLogStatus", err.Error())
+ }
+
+ req, err := client.GetFlowLogStatusPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetFlowLogStatus", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetFlowLogStatusSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetFlowLogStatus", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetFlowLogStatusPreparer prepares the GetFlowLogStatus request.
+func (client WatchersClient) GetFlowLogStatusPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters FlowLogStatusParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/queryFlowLogStatus", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetFlowLogStatusSender sends the GetFlowLogStatus request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetFlowLogStatusSender(req *http.Request) (future WatchersGetFlowLogStatusFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (fli FlowLogInformation, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetFlowLogStatusFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersGetFlowLogStatusFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ fli.Response.Response, err = future.GetResult(sender)
+ if fli.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetFlowLogStatusFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && fli.Response.Response.StatusCode != http.StatusNoContent {
+ fli, err = client.GetFlowLogStatusResponder(fli.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetFlowLogStatusFuture", "Result", fli.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetFlowLogStatusResponder handles the response to the GetFlowLogStatus request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetFlowLogStatusResponder(resp *http.Response) (result FlowLogInformation, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetNextHop gets the next hop from the specified VM.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// parameters - parameters that define the source and destination endpoint.
+func (client WatchersClient) GetNextHop(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters NextHopParameters) (result WatchersGetNextHopFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.GetNextHop")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.TargetResourceID", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.SourceIPAddress", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.DestinationIPAddress", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "GetNextHop", err.Error())
+ }
+
+ req, err := client.GetNextHopPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetNextHop", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetNextHopSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetNextHop", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetNextHopPreparer prepares the GetNextHop request.
+func (client WatchersClient) GetNextHopPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters NextHopParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/nextHop", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetNextHopSender sends the GetNextHop request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetNextHopSender(req *http.Request) (future WatchersGetNextHopFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (nhr NextHopResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetNextHopFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersGetNextHopFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ nhr.Response.Response, err = future.GetResult(sender)
+ if nhr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetNextHopFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && nhr.Response.Response.StatusCode != http.StatusNoContent {
+ nhr, err = client.GetNextHopResponder(nhr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetNextHopFuture", "Result", nhr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetNextHopResponder handles the response to the GetNextHop request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetNextHopResponder(resp *http.Response) (result NextHopResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetTopology gets the current network topology by resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// parameters - parameters that define the representation of topology.
+func (client WatchersClient) GetTopology(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters TopologyParameters) (result Topology, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.GetTopology")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.GetTopologyPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetTopology", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetTopologySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetTopology", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetTopologyResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetTopology", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetTopologyPreparer prepares the GetTopology request.
+func (client WatchersClient) GetTopologyPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters TopologyParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/topology", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetTopologySender sends the GetTopology request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetTopologySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetTopologyResponder handles the response to the GetTopology request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetTopologyResponder(resp *http.Response) (result Topology, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetTroubleshooting initiate troubleshooting on a specified resource
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher resource.
+// parameters - parameters that define the resource to troubleshoot.
+func (client WatchersClient) GetTroubleshooting(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters TroubleshootingParameters) (result WatchersGetTroubleshootingFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.GetTroubleshooting")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.TargetResourceID", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.TroubleshootingProperties", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.TroubleshootingProperties.StorageID", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.TroubleshootingProperties.StoragePath", Name: validation.Null, Rule: true, Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "GetTroubleshooting", err.Error())
+ }
+
+ req, err := client.GetTroubleshootingPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetTroubleshooting", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetTroubleshootingSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetTroubleshooting", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetTroubleshootingPreparer prepares the GetTroubleshooting request.
+func (client WatchersClient) GetTroubleshootingPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters TroubleshootingParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/troubleshoot", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetTroubleshootingSender sends the GetTroubleshooting request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetTroubleshootingSender(req *http.Request) (future WatchersGetTroubleshootingFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (tr TroubleshootingResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetTroubleshootingFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersGetTroubleshootingFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ tr.Response.Response, err = future.GetResult(sender)
+ if tr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetTroubleshootingFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && tr.Response.Response.StatusCode != http.StatusNoContent {
+ tr, err = client.GetTroubleshootingResponder(tr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetTroubleshootingFuture", "Result", tr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetTroubleshootingResponder handles the response to the GetTroubleshooting request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetTroubleshootingResponder(resp *http.Response) (result TroubleshootingResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetTroubleshootingResult get the last completed troubleshooting result on a specified resource
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher resource.
+// parameters - parameters that define the resource to query the troubleshooting result.
+func (client WatchersClient) GetTroubleshootingResult(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters QueryTroubleshootingParameters) (result WatchersGetTroubleshootingResultFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.GetTroubleshootingResult")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.TargetResourceID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "GetTroubleshootingResult", err.Error())
+ }
+
+ req, err := client.GetTroubleshootingResultPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetTroubleshootingResult", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetTroubleshootingResultSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetTroubleshootingResult", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetTroubleshootingResultPreparer prepares the GetTroubleshootingResult request.
+func (client WatchersClient) GetTroubleshootingResultPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters QueryTroubleshootingParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/queryTroubleshootResult", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetTroubleshootingResultSender sends the GetTroubleshootingResult request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetTroubleshootingResultSender(req *http.Request) (future WatchersGetTroubleshootingResultFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (tr TroubleshootingResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetTroubleshootingResultFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersGetTroubleshootingResultFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ tr.Response.Response, err = future.GetResult(sender)
+ if tr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetTroubleshootingResultFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && tr.Response.Response.StatusCode != http.StatusNoContent {
+ tr, err = client.GetTroubleshootingResultResponder(tr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetTroubleshootingResultFuture", "Result", tr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetTroubleshootingResultResponder handles the response to the GetTroubleshootingResult request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetTroubleshootingResultResponder(resp *http.Response) (result TroubleshootingResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVMSecurityRules gets the configured and effective security group rules on the specified VM.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// parameters - parameters that define the VM to check security groups for.
+func (client WatchersClient) GetVMSecurityRules(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters SecurityGroupViewParameters) (result WatchersGetVMSecurityRulesFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.GetVMSecurityRules")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.TargetResourceID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "GetVMSecurityRules", err.Error())
+ }
+
+ req, err := client.GetVMSecurityRulesPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetVMSecurityRules", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.GetVMSecurityRulesSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "GetVMSecurityRules", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// GetVMSecurityRulesPreparer prepares the GetVMSecurityRules request.
+func (client WatchersClient) GetVMSecurityRulesPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters SecurityGroupViewParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/securityGroupView", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetVMSecurityRulesSender sends the GetVMSecurityRules request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) GetVMSecurityRulesSender(req *http.Request) (future WatchersGetVMSecurityRulesFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (sgvr SecurityGroupViewResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetVMSecurityRulesFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersGetVMSecurityRulesFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ sgvr.Response.Response, err = future.GetResult(sender)
+ if sgvr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetVMSecurityRulesFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && sgvr.Response.Response.StatusCode != http.StatusNoContent {
+ sgvr, err = client.GetVMSecurityRulesResponder(sgvr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersGetVMSecurityRulesFuture", "Result", sgvr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// GetVMSecurityRulesResponder handles the response to the GetVMSecurityRules request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) GetVMSecurityRulesResponder(resp *http.Response) (result SecurityGroupViewResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List gets all network watchers by resource group.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+func (client WatchersClient) List(ctx context.Context, resourceGroupName string) (result WatcherListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client WatchersClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) ListResponder(resp *http.Response) (result WatcherListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAll gets all network watchers by subscription.
+func (client WatchersClient) ListAll(ctx context.Context) (result WatcherListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.ListAll")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListAllPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "ListAll", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAllSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "ListAll", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAllResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "ListAll", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListAllPreparer prepares the ListAll request.
+func (client WatchersClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/networkWatchers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAllSender sends the ListAll request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) ListAllSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAllResponder handles the response to the ListAll request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) ListAllResponder(resp *http.Response) (result WatcherListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAvailableProviders lists all available internet service providers for a specified Azure region.
+// Parameters:
+// resourceGroupName - the name of the network watcher resource group.
+// networkWatcherName - the name of the network watcher resource.
+// parameters - parameters that scope the list of available providers.
+func (client WatchersClient) ListAvailableProviders(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters AvailableProvidersListParameters) (result WatchersListAvailableProvidersFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.ListAvailableProviders")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListAvailableProvidersPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "ListAvailableProviders", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.ListAvailableProvidersSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "ListAvailableProviders", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// ListAvailableProvidersPreparer prepares the ListAvailableProviders request.
+func (client WatchersClient) ListAvailableProvidersPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters AvailableProvidersListParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/availableProvidersList", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAvailableProvidersSender sends the ListAvailableProviders request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) ListAvailableProvidersSender(req *http.Request) (future WatchersListAvailableProvidersFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (apl AvailableProvidersList, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersListAvailableProvidersFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersListAvailableProvidersFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ apl.Response.Response, err = future.GetResult(sender)
+ if apl.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersListAvailableProvidersFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && apl.Response.Response.StatusCode != http.StatusNoContent {
+ apl, err = client.ListAvailableProvidersResponder(apl.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersListAvailableProvidersFuture", "Result", apl.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// ListAvailableProvidersResponder handles the response to the ListAvailableProviders request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) ListAvailableProvidersResponder(resp *http.Response) (result AvailableProvidersList, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// SetFlowLogConfiguration configures flow log on a specified resource.
+// Parameters:
+// resourceGroupName - the name of the network watcher resource group.
+// networkWatcherName - the name of the network watcher resource.
+// parameters - parameters that define the configuration of flow log.
+func (client WatchersClient) SetFlowLogConfiguration(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters FlowLogInformation) (result WatchersSetFlowLogConfigurationFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.SetFlowLogConfiguration")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.TargetResourceID", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.FlowLogProperties", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.FlowLogProperties.StorageID", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.FlowLogProperties.Enabled", Name: validation.Null, Rule: true, Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "SetFlowLogConfiguration", err.Error())
+ }
+
+ req, err := client.SetFlowLogConfigurationPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "SetFlowLogConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.SetFlowLogConfigurationSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "SetFlowLogConfiguration", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// SetFlowLogConfigurationPreparer prepares the SetFlowLogConfiguration request.
+func (client WatchersClient) SetFlowLogConfigurationPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters FlowLogInformation) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/configureFlowLog", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// SetFlowLogConfigurationSender sends the SetFlowLogConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) SetFlowLogConfigurationSender(req *http.Request) (future WatchersSetFlowLogConfigurationFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (fli FlowLogInformation, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersSetFlowLogConfigurationFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersSetFlowLogConfigurationFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ fli.Response.Response, err = future.GetResult(sender)
+ if fli.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersSetFlowLogConfigurationFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && fli.Response.Response.StatusCode != http.StatusNoContent {
+ fli, err = client.SetFlowLogConfigurationResponder(fli.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersSetFlowLogConfigurationFuture", "Result", fli.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// SetFlowLogConfigurationResponder handles the response to the SetFlowLogConfiguration request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) SetFlowLogConfigurationResponder(resp *http.Response) (result FlowLogInformation, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateTags updates a network watcher tags.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// parameters - parameters supplied to update network watcher tags.
+func (client WatchersClient) UpdateTags(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters TagsObject) (result Watcher, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.UpdateTags")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "UpdateTags", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateTagsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "UpdateTags", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateTagsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "UpdateTags", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// UpdateTagsPreparer prepares the UpdateTags request.
+func (client WatchersClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters TagsObject) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateTagsSender sends the UpdateTags request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) UpdateTagsSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// UpdateTagsResponder handles the response to the UpdateTags request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) UpdateTagsResponder(resp *http.Response) (result Watcher, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// VerifyIPFlow verify IP flow from the specified VM to a location given the currently configured NSG rules.
+// Parameters:
+// resourceGroupName - the name of the resource group.
+// networkWatcherName - the name of the network watcher.
+// parameters - parameters that define the IP flow to be verified.
+func (client WatchersClient) VerifyIPFlow(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters VerificationIPFlowParameters) (result WatchersVerifyIPFlowFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/WatchersClient.VerifyIPFlow")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.TargetResourceID", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.LocalPort", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.RemotePort", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.LocalIPAddress", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.RemoteIPAddress", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("network.WatchersClient", "VerifyIPFlow", err.Error())
+ }
+
+ req, err := client.VerifyIPFlowPreparer(ctx, resourceGroupName, networkWatcherName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "VerifyIPFlow", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.VerifyIPFlowSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersClient", "VerifyIPFlow", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// VerifyIPFlowPreparer prepares the VerifyIPFlow request.
+func (client WatchersClient) VerifyIPFlowPreparer(ctx context.Context, resourceGroupName string, networkWatcherName string, parameters VerificationIPFlowParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "networkWatcherName": autorest.Encode("path", networkWatcherName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkWatchers/{networkWatcherName}/ipFlowVerify", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// VerifyIPFlowSender sends the VerifyIPFlow request. The method will close the
+// http.Response Body if it receives an error.
+func (client WatchersClient) VerifyIPFlowSender(req *http.Request) (future WatchersVerifyIPFlowFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client WatchersClient) (vifr VerificationIPFlowResult, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersVerifyIPFlowFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("network.WatchersVerifyIPFlowFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ vifr.Response.Response, err = future.GetResult(sender)
+ if vifr.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersVerifyIPFlowFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && vifr.Response.Response.StatusCode != http.StatusNoContent {
+ vifr, err = client.VerifyIPFlowResponder(vifr.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "network.WatchersVerifyIPFlowFuture", "Result", vifr.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// VerifyIPFlowResponder handles the response to the VerifyIPFlow request. The method always
+// closes the http.Response Body.
+func (client WatchersClient) VerifyIPFlowResponder(resp *http.Response) (result VerificationIPFlowResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/CHANGELOG.md b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/CHANGELOG.md
new file mode 100644
index 00000000000..adfe7d67ddd
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/CHANGELOG.md
@@ -0,0 +1,5 @@
+Generated from https://github.com/Azure/azure-rest-api-specs/tree/3c764635e7d442b3e74caf593029fcd440b3ef82//specification/storage/resource-manager/readme.md tag: `package-2017-10`
+
+Code generator @microsoft.azure/autorest.go@2.1.171
+
+
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/accounts.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/accounts.go
new file mode 100644
index 00000000000..653b21beb48
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/accounts.go
@@ -0,0 +1,1059 @@
+package storage
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// AccountsClient is the the Azure Storage Management API.
+type AccountsClient struct {
+ BaseClient
+}
+
+// NewAccountsClient creates an instance of the AccountsClient client.
+func NewAccountsClient(subscriptionID string) AccountsClient {
+ return NewAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewAccountsClientWithBaseURI creates an instance of the AccountsClient client using a custom endpoint. Use this
+// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewAccountsClientWithBaseURI(baseURI string, subscriptionID string) AccountsClient {
+ return AccountsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CheckNameAvailability checks that the storage account name is valid and is not already in use.
+// Parameters:
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+func (client AccountsClient) CheckNameAvailability(ctx context.Context, accountName AccountCheckNameAvailabilityParameters) (result CheckNameAvailabilityResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.CheckNameAvailability")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName.Name", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "accountName.Type", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "CheckNameAvailability", err.Error())
+ }
+
+ req, err := client.CheckNameAvailabilityPreparer(ctx, accountName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "CheckNameAvailability", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CheckNameAvailabilitySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "CheckNameAvailability", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CheckNameAvailabilityResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "CheckNameAvailability", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request.
+func (client AccountsClient) CheckNameAvailabilityPreparer(ctx context.Context, accountName AccountCheckNameAvailabilityParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/checkNameAvailability", pathParameters),
+ autorest.WithJSON(accountName),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) CheckNameAvailabilityResponder(resp *http.Response) (result CheckNameAvailabilityResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Create asynchronously creates a new storage account with the specified parameters. If an account is already created
+// and a subsequent create request is issued with different properties, the account properties will be updated. If an
+// account is already created and a subsequent create or update request is issued with the exact same set of
+// properties, the request will succeed.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+// parameters - the parameters to provide for the created account.
+func (client AccountsClient) Create(ctx context.Context, resourceGroupName string, accountName string, parameters AccountCreateParameters) (result AccountsCreateFuture, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Create")
+ defer func() {
+ sc := -1
+ if result.Response() != nil {
+ sc = result.Response().StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.Sku", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.Location", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.Identity", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.Identity.Type", Name: validation.Null, Rule: true, Chain: nil}}},
+ {Target: "parameters.AccountPropertiesCreateParameters", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.CustomDomain", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.AccountPropertiesCreateParameters.CustomDomain.Name", Name: validation.Null, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "Create", err.Error())
+ }
+
+ req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Create", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Create", nil, "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreatePreparer prepares the Create request.
+func (client AccountsClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters AccountCreateParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateSender sends the Create request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) CreateSender(req *http.Request) (future AccountsCreateFuture, err error) {
+ var resp *http.Response
+ resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
+ if err != nil {
+ return
+ }
+ var azf azure.Future
+ azf, err = azure.NewFutureFromResponse(resp)
+ future.FutureAPI = &azf
+ future.Result = func(client AccountsClient) (a Account, err error) {
+ var done bool
+ done, err = future.DoneWithContext(context.Background(), client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsCreateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ err = azure.NewAsyncOpIncompleteError("storage.AccountsCreateFuture")
+ return
+ }
+ sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ a.Response.Response, err = future.GetResult(sender)
+ if a.Response.Response == nil && err == nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsCreateFuture", "Result", nil, "received nil response and error")
+ }
+ if err == nil && a.Response.Response.StatusCode != http.StatusNoContent {
+ a, err = client.CreateResponder(a.Response.Response)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsCreateFuture", "Result", a.Response.Response, "Failure responding to request")
+ }
+ }
+ return
+ }
+ return
+}
+
+// CreateResponder handles the response to the Create request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) CreateResponder(resp *http.Response) (result Account, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes a storage account in Microsoft Azure.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+func (client AccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result autorest.Response, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Delete")
+ defer func() {
+ sc := -1
+ if result.Response != nil {
+ sc = result.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "Delete", err.Error())
+ }
+
+ req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Delete", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client AccountsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// GetProperties returns the properties for the specified storage account including but not limited to name, SKU name,
+// location, and account status. The ListKeys operation should be used to retrieve storage keys.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+func (client AccountsClient) GetProperties(ctx context.Context, resourceGroupName string, accountName string) (result Account, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.GetProperties")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "GetProperties", err.Error())
+ }
+
+ req, err := client.GetPropertiesPreparer(ctx, resourceGroupName, accountName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "GetProperties", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetPropertiesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "GetProperties", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetPropertiesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "GetProperties", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// GetPropertiesPreparer prepares the GetProperties request.
+func (client AccountsClient) GetPropertiesPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetPropertiesSender sends the GetProperties request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) GetPropertiesSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetPropertiesResponder handles the response to the GetProperties request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) GetPropertiesResponder(resp *http.Response) (result Account, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List lists all the storage accounts available under the subscription. Note that storage keys are not returned; use
+// the ListKeys operation for this.
+func (client AccountsClient) List(ctx context.Context) (result AccountListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client AccountsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/storageAccounts", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) ListResponder(resp *http.Response) (result AccountListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAccountSAS list SAS credentials of a storage account.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+// parameters - the parameters to provide to list SAS credentials for the storage account.
+func (client AccountsClient) ListAccountSAS(ctx context.Context, resourceGroupName string, accountName string, parameters AccountSasParameters) (result ListAccountSasResponse, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListAccountSAS")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.SharedAccessExpiryTime", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "ListAccountSAS", err.Error())
+ }
+
+ req, err := client.ListAccountSASPreparer(ctx, resourceGroupName, accountName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListAccountSAS", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAccountSASSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListAccountSAS", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAccountSASResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListAccountSAS", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListAccountSASPreparer prepares the ListAccountSAS request.
+func (client AccountsClient) ListAccountSASPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters AccountSasParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/ListAccountSas", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAccountSASSender sends the ListAccountSAS request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) ListAccountSASSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAccountSASResponder handles the response to the ListAccountSAS request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) ListAccountSASResponder(resp *http.Response) (result ListAccountSasResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroup lists all the storage accounts available under the given resource group. Note that storage keys
+// are not returned; use the ListKeys operation for this.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+func (client AccountsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result AccountListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListByResourceGroup")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "ListByResourceGroup", err.Error())
+ }
+
+ req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListByResourceGroup", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client AccountsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) ListByResourceGroupResponder(resp *http.Response) (result AccountListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListKeys lists the access keys for the specified storage account.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+func (client AccountsClient) ListKeys(ctx context.Context, resourceGroupName string, accountName string) (result AccountListKeysResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListKeys")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "ListKeys", err.Error())
+ }
+
+ req, err := client.ListKeysPreparer(ctx, resourceGroupName, accountName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListKeys", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListKeysPreparer prepares the ListKeys request.
+func (client AccountsClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/listKeys", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListKeysSender sends the ListKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) ListKeysSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListKeysResponder handles the response to the ListKeys request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) ListKeysResponder(resp *http.Response) (result AccountListKeysResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListServiceSAS list service SAS credentials of a specific resource.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+// parameters - the parameters to provide to list service SAS credentials.
+func (client AccountsClient) ListServiceSAS(ctx context.Context, resourceGroupName string, accountName string, parameters ServiceSasParameters) (result ListServiceSasResponse, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListServiceSAS")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.CanonicalizedResource", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "parameters.Identifier", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.Identifier", Name: validation.MaxLength, Rule: 64, Chain: nil}}}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "ListServiceSAS", err.Error())
+ }
+
+ req, err := client.ListServiceSASPreparer(ctx, resourceGroupName, accountName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListServiceSAS", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListServiceSASSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListServiceSAS", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListServiceSASResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "ListServiceSAS", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListServiceSASPreparer prepares the ListServiceSAS request.
+func (client AccountsClient) ListServiceSASPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters ServiceSasParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/ListServiceSas", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListServiceSASSender sends the ListServiceSAS request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) ListServiceSASSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListServiceSASResponder handles the response to the ListServiceSAS request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) ListServiceSASResponder(resp *http.Response) (result ListServiceSasResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RegenerateKey regenerates one of the access keys for the specified storage account.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+// regenerateKey - specifies name of the key which should be regenerated -- key1 or key2.
+func (client AccountsClient) RegenerateKey(ctx context.Context, resourceGroupName string, accountName string, regenerateKey AccountRegenerateKeyParameters) (result AccountListKeysResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.RegenerateKey")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}},
+ {TargetValue: regenerateKey,
+ Constraints: []validation.Constraint{{Target: "regenerateKey.KeyName", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "RegenerateKey", err.Error())
+ }
+
+ req, err := client.RegenerateKeyPreparer(ctx, resourceGroupName, accountName, regenerateKey)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RegenerateKey", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RegenerateKeySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RegenerateKey", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RegenerateKeyResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "RegenerateKey", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// RegenerateKeyPreparer prepares the RegenerateKey request.
+func (client AccountsClient) RegenerateKeyPreparer(ctx context.Context, resourceGroupName string, accountName string, regenerateKey AccountRegenerateKeyParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}/regenerateKey", pathParameters),
+ autorest.WithJSON(regenerateKey),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RegenerateKeySender sends the RegenerateKey request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) RegenerateKeySender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// RegenerateKeyResponder handles the response to the RegenerateKey request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) RegenerateKeyResponder(resp *http.Response) (result AccountListKeysResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update the update operation can be used to update the SKU, encryption, access tier, or tags for a storage account.
+// It can also be used to map the account to a custom domain. Only one custom domain is supported per storage account;
+// the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value
+// must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This
+// call does not change the storage keys for the account. If you want to change the storage account keys, use the
+// regenerate keys operation. The location and name of the storage account cannot be changed after creation.
+// Parameters:
+// resourceGroupName - the name of the resource group within the user's subscription. The name is case
+// insensitive.
+// accountName - the name of the storage account within the specified resource group. Storage account names
+// must be between 3 and 24 characters in length and use numbers and lower-case letters only.
+// parameters - the parameters to provide for the updated account.
+func (client AccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, parameters AccountUpdateParameters) (result Account, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Update")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
+ {TargetValue: accountName,
+ Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil},
+ {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("storage.AccountsClient", "Update", err.Error())
+ }
+
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Update", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.AccountsClient", "Update", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client AccountsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters AccountUpdateParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "accountName": autorest.Encode("path", accountName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client AccountsClient) UpdateSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client AccountsClient) UpdateResponder(resp *http.Response) (result Account, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/client.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/client.go
new file mode 100644
index 00000000000..abba376eda8
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/client.go
@@ -0,0 +1,52 @@
+// Package storage implements the Azure ARM Storage service API version 2017-10-01.
+//
+// The Azure Storage Management API.
+package storage
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+)
+
+const (
+ // DefaultBaseURI is the default URI used for the service Storage
+ DefaultBaseURI = "https://management.azure.com"
+)
+
+// BaseClient is the base client for Storage.
+type BaseClient struct {
+ autorest.Client
+ BaseURI string
+ SubscriptionID string
+}
+
+// New creates an instance of the BaseClient client.
+func New(subscriptionID string) BaseClient {
+ return NewWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint. Use this when interacting with
+// an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+ return BaseClient{
+ Client: autorest.NewClientWithUserAgent(UserAgent()),
+ BaseURI: baseURI,
+ SubscriptionID: subscriptionID,
+ }
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/enums.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/enums.go
new file mode 100644
index 00000000000..8793f92a192
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/enums.go
@@ -0,0 +1,366 @@
+package storage
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// AccessTier enumerates the values for access tier.
+type AccessTier string
+
+const (
+ // Cool ...
+ Cool AccessTier = "Cool"
+ // Hot ...
+ Hot AccessTier = "Hot"
+)
+
+// PossibleAccessTierValues returns an array of possible values for the AccessTier const type.
+func PossibleAccessTierValues() []AccessTier {
+ return []AccessTier{Cool, Hot}
+}
+
+// AccountStatus enumerates the values for account status.
+type AccountStatus string
+
+const (
+ // Available ...
+ Available AccountStatus = "available"
+ // Unavailable ...
+ Unavailable AccountStatus = "unavailable"
+)
+
+// PossibleAccountStatusValues returns an array of possible values for the AccountStatus const type.
+func PossibleAccountStatusValues() []AccountStatus {
+ return []AccountStatus{Available, Unavailable}
+}
+
+// Action enumerates the values for action.
+type Action string
+
+const (
+ // Allow ...
+ Allow Action = "Allow"
+)
+
+// PossibleActionValues returns an array of possible values for the Action const type.
+func PossibleActionValues() []Action {
+ return []Action{Allow}
+}
+
+// Bypass enumerates the values for bypass.
+type Bypass string
+
+const (
+ // AzureServices ...
+ AzureServices Bypass = "AzureServices"
+ // Logging ...
+ Logging Bypass = "Logging"
+ // Metrics ...
+ Metrics Bypass = "Metrics"
+ // None ...
+ None Bypass = "None"
+)
+
+// PossibleBypassValues returns an array of possible values for the Bypass const type.
+func PossibleBypassValues() []Bypass {
+ return []Bypass{AzureServices, Logging, Metrics, None}
+}
+
+// DefaultAction enumerates the values for default action.
+type DefaultAction string
+
+const (
+ // DefaultActionAllow ...
+ DefaultActionAllow DefaultAction = "Allow"
+ // DefaultActionDeny ...
+ DefaultActionDeny DefaultAction = "Deny"
+)
+
+// PossibleDefaultActionValues returns an array of possible values for the DefaultAction const type.
+func PossibleDefaultActionValues() []DefaultAction {
+ return []DefaultAction{DefaultActionAllow, DefaultActionDeny}
+}
+
+// HTTPProtocol enumerates the values for http protocol.
+type HTTPProtocol string
+
+const (
+ // HTTPS ...
+ HTTPS HTTPProtocol = "https"
+ // Httpshttp ...
+ Httpshttp HTTPProtocol = "https,http"
+)
+
+// PossibleHTTPProtocolValues returns an array of possible values for the HTTPProtocol const type.
+func PossibleHTTPProtocolValues() []HTTPProtocol {
+ return []HTTPProtocol{HTTPS, Httpshttp}
+}
+
+// KeyPermission enumerates the values for key permission.
+type KeyPermission string
+
+const (
+ // Full ...
+ Full KeyPermission = "Full"
+ // Read ...
+ Read KeyPermission = "Read"
+)
+
+// PossibleKeyPermissionValues returns an array of possible values for the KeyPermission const type.
+func PossibleKeyPermissionValues() []KeyPermission {
+ return []KeyPermission{Full, Read}
+}
+
+// KeySource enumerates the values for key source.
+type KeySource string
+
+const (
+ // MicrosoftKeyvault ...
+ MicrosoftKeyvault KeySource = "Microsoft.Keyvault"
+ // MicrosoftStorage ...
+ MicrosoftStorage KeySource = "Microsoft.Storage"
+)
+
+// PossibleKeySourceValues returns an array of possible values for the KeySource const type.
+func PossibleKeySourceValues() []KeySource {
+ return []KeySource{MicrosoftKeyvault, MicrosoftStorage}
+}
+
+// Kind enumerates the values for kind.
+type Kind string
+
+const (
+ // BlobStorage ...
+ BlobStorage Kind = "BlobStorage"
+ // Storage ...
+ Storage Kind = "Storage"
+ // StorageV2 ...
+ StorageV2 Kind = "StorageV2"
+)
+
+// PossibleKindValues returns an array of possible values for the Kind const type.
+func PossibleKindValues() []Kind {
+ return []Kind{BlobStorage, Storage, StorageV2}
+}
+
+// Permissions enumerates the values for permissions.
+type Permissions string
+
+const (
+ // A ...
+ A Permissions = "a"
+ // C ...
+ C Permissions = "c"
+ // D ...
+ D Permissions = "d"
+ // L ...
+ L Permissions = "l"
+ // P ...
+ P Permissions = "p"
+ // R ...
+ R Permissions = "r"
+ // U ...
+ U Permissions = "u"
+ // W ...
+ W Permissions = "w"
+)
+
+// PossiblePermissionsValues returns an array of possible values for the Permissions const type.
+func PossiblePermissionsValues() []Permissions {
+ return []Permissions{A, C, D, L, P, R, U, W}
+}
+
+// ProvisioningState enumerates the values for provisioning state.
+type ProvisioningState string
+
+const (
+ // Creating ...
+ Creating ProvisioningState = "Creating"
+ // ResolvingDNS ...
+ ResolvingDNS ProvisioningState = "ResolvingDNS"
+ // Succeeded ...
+ Succeeded ProvisioningState = "Succeeded"
+)
+
+// PossibleProvisioningStateValues returns an array of possible values for the ProvisioningState const type.
+func PossibleProvisioningStateValues() []ProvisioningState {
+ return []ProvisioningState{Creating, ResolvingDNS, Succeeded}
+}
+
+// Reason enumerates the values for reason.
+type Reason string
+
+const (
+ // AccountNameInvalid ...
+ AccountNameInvalid Reason = "AccountNameInvalid"
+ // AlreadyExists ...
+ AlreadyExists Reason = "AlreadyExists"
+)
+
+// PossibleReasonValues returns an array of possible values for the Reason const type.
+func PossibleReasonValues() []Reason {
+ return []Reason{AccountNameInvalid, AlreadyExists}
+}
+
+// ReasonCode enumerates the values for reason code.
+type ReasonCode string
+
+const (
+ // NotAvailableForSubscription ...
+ NotAvailableForSubscription ReasonCode = "NotAvailableForSubscription"
+ // QuotaID ...
+ QuotaID ReasonCode = "QuotaId"
+)
+
+// PossibleReasonCodeValues returns an array of possible values for the ReasonCode const type.
+func PossibleReasonCodeValues() []ReasonCode {
+ return []ReasonCode{NotAvailableForSubscription, QuotaID}
+}
+
+// Services enumerates the values for services.
+type Services string
+
+const (
+ // B ...
+ B Services = "b"
+ // F ...
+ F Services = "f"
+ // Q ...
+ Q Services = "q"
+ // T ...
+ T Services = "t"
+)
+
+// PossibleServicesValues returns an array of possible values for the Services const type.
+func PossibleServicesValues() []Services {
+ return []Services{B, F, Q, T}
+}
+
+// SignedResource enumerates the values for signed resource.
+type SignedResource string
+
+const (
+ // SignedResourceB ...
+ SignedResourceB SignedResource = "b"
+ // SignedResourceC ...
+ SignedResourceC SignedResource = "c"
+ // SignedResourceF ...
+ SignedResourceF SignedResource = "f"
+ // SignedResourceS ...
+ SignedResourceS SignedResource = "s"
+)
+
+// PossibleSignedResourceValues returns an array of possible values for the SignedResource const type.
+func PossibleSignedResourceValues() []SignedResource {
+ return []SignedResource{SignedResourceB, SignedResourceC, SignedResourceF, SignedResourceS}
+}
+
+// SignedResourceTypes enumerates the values for signed resource types.
+type SignedResourceTypes string
+
+const (
+ // SignedResourceTypesC ...
+ SignedResourceTypesC SignedResourceTypes = "c"
+ // SignedResourceTypesO ...
+ SignedResourceTypesO SignedResourceTypes = "o"
+ // SignedResourceTypesS ...
+ SignedResourceTypesS SignedResourceTypes = "s"
+)
+
+// PossibleSignedResourceTypesValues returns an array of possible values for the SignedResourceTypes const type.
+func PossibleSignedResourceTypesValues() []SignedResourceTypes {
+ return []SignedResourceTypes{SignedResourceTypesC, SignedResourceTypesO, SignedResourceTypesS}
+}
+
+// SkuName enumerates the values for sku name.
+type SkuName string
+
+const (
+ // PremiumLRS ...
+ PremiumLRS SkuName = "Premium_LRS"
+ // StandardGRS ...
+ StandardGRS SkuName = "Standard_GRS"
+ // StandardLRS ...
+ StandardLRS SkuName = "Standard_LRS"
+ // StandardRAGRS ...
+ StandardRAGRS SkuName = "Standard_RAGRS"
+ // StandardZRS ...
+ StandardZRS SkuName = "Standard_ZRS"
+)
+
+// PossibleSkuNameValues returns an array of possible values for the SkuName const type.
+func PossibleSkuNameValues() []SkuName {
+ return []SkuName{PremiumLRS, StandardGRS, StandardLRS, StandardRAGRS, StandardZRS}
+}
+
+// SkuTier enumerates the values for sku tier.
+type SkuTier string
+
+const (
+ // Premium ...
+ Premium SkuTier = "Premium"
+ // Standard ...
+ Standard SkuTier = "Standard"
+)
+
+// PossibleSkuTierValues returns an array of possible values for the SkuTier const type.
+func PossibleSkuTierValues() []SkuTier {
+ return []SkuTier{Premium, Standard}
+}
+
+// State enumerates the values for state.
+type State string
+
+const (
+ // StateDeprovisioning ...
+ StateDeprovisioning State = "deprovisioning"
+ // StateFailed ...
+ StateFailed State = "failed"
+ // StateNetworkSourceDeleted ...
+ StateNetworkSourceDeleted State = "networkSourceDeleted"
+ // StateProvisioning ...
+ StateProvisioning State = "provisioning"
+ // StateSucceeded ...
+ StateSucceeded State = "succeeded"
+)
+
+// PossibleStateValues returns an array of possible values for the State const type.
+func PossibleStateValues() []State {
+ return []State{StateDeprovisioning, StateFailed, StateNetworkSourceDeleted, StateProvisioning, StateSucceeded}
+}
+
+// UsageUnit enumerates the values for usage unit.
+type UsageUnit string
+
+const (
+ // Bytes ...
+ Bytes UsageUnit = "Bytes"
+ // BytesPerSecond ...
+ BytesPerSecond UsageUnit = "BytesPerSecond"
+ // Count ...
+ Count UsageUnit = "Count"
+ // CountsPerSecond ...
+ CountsPerSecond UsageUnit = "CountsPerSecond"
+ // Percent ...
+ Percent UsageUnit = "Percent"
+ // Seconds ...
+ Seconds UsageUnit = "Seconds"
+)
+
+// PossibleUsageUnitValues returns an array of possible values for the UsageUnit const type.
+func PossibleUsageUnitValues() []UsageUnit {
+ return []UsageUnit{Bytes, BytesPerSecond, Count, CountsPerSecond, Percent, Seconds}
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/models.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/models.go
new file mode 100644
index 00000000000..8576a04fbcb
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/models.go
@@ -0,0 +1,961 @@
+package storage
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "encoding/json"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/date"
+)
+
+// The package's fully qualified name.
+const fqdn = "github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage"
+
+// Account the storage account.
+type Account struct {
+ autorest.Response `json:"-"`
+ // Sku - READ-ONLY; Gets the SKU.
+ Sku *Sku `json:"sku,omitempty"`
+ // Kind - READ-ONLY; Gets the Kind. Possible values include: 'Storage', 'StorageV2', 'BlobStorage'
+ Kind Kind `json:"kind,omitempty"`
+ // Identity - The identity of the resource.
+ Identity *Identity `json:"identity,omitempty"`
+ // AccountProperties - Properties of the storage account.
+ *AccountProperties `json:"properties,omitempty"`
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Tags assigned to a resource; can be used for viewing and grouping a resource (across resource groups).
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Account.
+func (a Account) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if a.Identity != nil {
+ objectMap["identity"] = a.Identity
+ }
+ if a.AccountProperties != nil {
+ objectMap["properties"] = a.AccountProperties
+ }
+ if a.Location != nil {
+ objectMap["location"] = a.Location
+ }
+ if a.Tags != nil {
+ objectMap["tags"] = a.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Account struct.
+func (a *Account) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ a.Sku = &sku
+ }
+ case "kind":
+ if v != nil {
+ var kind Kind
+ err = json.Unmarshal(*v, &kind)
+ if err != nil {
+ return err
+ }
+ a.Kind = kind
+ }
+ case "identity":
+ if v != nil {
+ var identity Identity
+ err = json.Unmarshal(*v, &identity)
+ if err != nil {
+ return err
+ }
+ a.Identity = &identity
+ }
+ case "properties":
+ if v != nil {
+ var accountProperties AccountProperties
+ err = json.Unmarshal(*v, &accountProperties)
+ if err != nil {
+ return err
+ }
+ a.AccountProperties = &accountProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ a.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ a.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ a.Type = &typeVar
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ a.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ a.Tags = tags
+ }
+ }
+ }
+
+ return nil
+}
+
+// AccountCheckNameAvailabilityParameters the parameters used to check the availability of the storage
+// account name.
+type AccountCheckNameAvailabilityParameters struct {
+ // Name - The storage account name.
+ Name *string `json:"name,omitempty"`
+ // Type - The type of resource, Microsoft.Storage/storageAccounts
+ Type *string `json:"type,omitempty"`
+}
+
+// AccountCreateParameters the parameters used when creating a storage account.
+type AccountCreateParameters struct {
+ // Sku - Required. Gets or sets the sku name.
+ Sku *Sku `json:"sku,omitempty"`
+ // Kind - Required. Indicates the type of storage account. Possible values include: 'Storage', 'StorageV2', 'BlobStorage'
+ Kind Kind `json:"kind,omitempty"`
+ // Location - Required. Gets or sets the location of the resource. This will be one of the supported and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia, etc.). The geo region of a resource cannot be changed once it is created, but if an identical geo region is specified on update, the request will succeed.
+ Location *string `json:"location,omitempty"`
+ // Tags - Gets or sets a list of key value pairs that describe the resource. These tags can be used for viewing and grouping this resource (across resource groups). A maximum of 15 tags can be provided for a resource. Each tag must have a key with a length no greater than 128 characters and a value with a length no greater than 256 characters.
+ Tags map[string]*string `json:"tags"`
+ // Identity - The identity of the resource.
+ Identity *Identity `json:"identity,omitempty"`
+ // AccountPropertiesCreateParameters - The parameters used to create the storage account.
+ *AccountPropertiesCreateParameters `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for AccountCreateParameters.
+func (acp AccountCreateParameters) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if acp.Sku != nil {
+ objectMap["sku"] = acp.Sku
+ }
+ if acp.Kind != "" {
+ objectMap["kind"] = acp.Kind
+ }
+ if acp.Location != nil {
+ objectMap["location"] = acp.Location
+ }
+ if acp.Tags != nil {
+ objectMap["tags"] = acp.Tags
+ }
+ if acp.Identity != nil {
+ objectMap["identity"] = acp.Identity
+ }
+ if acp.AccountPropertiesCreateParameters != nil {
+ objectMap["properties"] = acp.AccountPropertiesCreateParameters
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for AccountCreateParameters struct.
+func (acp *AccountCreateParameters) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ acp.Sku = &sku
+ }
+ case "kind":
+ if v != nil {
+ var kind Kind
+ err = json.Unmarshal(*v, &kind)
+ if err != nil {
+ return err
+ }
+ acp.Kind = kind
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ acp.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ acp.Tags = tags
+ }
+ case "identity":
+ if v != nil {
+ var identity Identity
+ err = json.Unmarshal(*v, &identity)
+ if err != nil {
+ return err
+ }
+ acp.Identity = &identity
+ }
+ case "properties":
+ if v != nil {
+ var accountPropertiesCreateParameters AccountPropertiesCreateParameters
+ err = json.Unmarshal(*v, &accountPropertiesCreateParameters)
+ if err != nil {
+ return err
+ }
+ acp.AccountPropertiesCreateParameters = &accountPropertiesCreateParameters
+ }
+ }
+ }
+
+ return nil
+}
+
+// AccountKey an access key for the storage account.
+type AccountKey struct {
+ // KeyName - READ-ONLY; Name of the key.
+ KeyName *string `json:"keyName,omitempty"`
+ // Value - READ-ONLY; Base 64-encoded value of the key.
+ Value *string `json:"value,omitempty"`
+ // Permissions - READ-ONLY; Permissions for the key -- read-only or full permissions. Possible values include: 'Read', 'Full'
+ Permissions KeyPermission `json:"permissions,omitempty"`
+}
+
+// AccountListKeysResult the response from the ListKeys operation.
+type AccountListKeysResult struct {
+ autorest.Response `json:"-"`
+ // Keys - READ-ONLY; Gets the list of storage account keys and their properties for the specified storage account.
+ Keys *[]AccountKey `json:"keys,omitempty"`
+}
+
+// AccountListResult the response from the List Storage Accounts operation.
+type AccountListResult struct {
+ autorest.Response `json:"-"`
+ // Value - READ-ONLY; Gets the list of storage accounts and their properties.
+ Value *[]Account `json:"value,omitempty"`
+}
+
+// AccountProperties properties of the storage account.
+type AccountProperties struct {
+ // ProvisioningState - READ-ONLY; Gets the status of the storage account at the time the operation was called. Possible values include: 'Creating', 'ResolvingDNS', 'Succeeded'
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+ // PrimaryEndpoints - READ-ONLY; Gets the URLs that are used to perform a retrieval of a public blob, queue, or table object. Note that Standard_ZRS and Premium_LRS accounts only return the blob endpoint.
+ PrimaryEndpoints *Endpoints `json:"primaryEndpoints,omitempty"`
+ // PrimaryLocation - READ-ONLY; Gets the location of the primary data center for the storage account.
+ PrimaryLocation *string `json:"primaryLocation,omitempty"`
+ // StatusOfPrimary - READ-ONLY; Gets the status indicating whether the primary location of the storage account is available or unavailable. Possible values include: 'Available', 'Unavailable'
+ StatusOfPrimary AccountStatus `json:"statusOfPrimary,omitempty"`
+ // LastGeoFailoverTime - READ-ONLY; Gets the timestamp of the most recent instance of a failover to the secondary location. Only the most recent timestamp is retained. This element is not returned if there has never been a failover instance. Only available if the accountType is Standard_GRS or Standard_RAGRS.
+ LastGeoFailoverTime *date.Time `json:"lastGeoFailoverTime,omitempty"`
+ // SecondaryLocation - READ-ONLY; Gets the location of the geo-replicated secondary for the storage account. Only available if the accountType is Standard_GRS or Standard_RAGRS.
+ SecondaryLocation *string `json:"secondaryLocation,omitempty"`
+ // StatusOfSecondary - READ-ONLY; Gets the status indicating whether the secondary location of the storage account is available or unavailable. Only available if the SKU name is Standard_GRS or Standard_RAGRS. Possible values include: 'Available', 'Unavailable'
+ StatusOfSecondary AccountStatus `json:"statusOfSecondary,omitempty"`
+ // CreationTime - READ-ONLY; Gets the creation date and time of the storage account in UTC.
+ CreationTime *date.Time `json:"creationTime,omitempty"`
+ // CustomDomain - READ-ONLY; Gets the custom domain the user assigned to this storage account.
+ CustomDomain *CustomDomain `json:"customDomain,omitempty"`
+ // SecondaryEndpoints - READ-ONLY; Gets the URLs that are used to perform a retrieval of a public blob, queue, or table object from the secondary location of the storage account. Only available if the SKU name is Standard_RAGRS.
+ SecondaryEndpoints *Endpoints `json:"secondaryEndpoints,omitempty"`
+ // Encryption - READ-ONLY; Gets the encryption settings on the account. If unspecified, the account is unencrypted.
+ Encryption *Encryption `json:"encryption,omitempty"`
+ // AccessTier - READ-ONLY; Required for storage accounts where kind = BlobStorage. The access tier used for billing. Possible values include: 'Hot', 'Cool'
+ AccessTier AccessTier `json:"accessTier,omitempty"`
+ // EnableHTTPSTrafficOnly - Allows https traffic only to storage service if sets to true.
+ EnableHTTPSTrafficOnly *bool `json:"supportsHttpsTrafficOnly,omitempty"`
+ // NetworkRuleSet - READ-ONLY; Network rule set
+ NetworkRuleSet *NetworkRuleSet `json:"networkAcls,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for AccountProperties.
+func (ap AccountProperties) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ap.EnableHTTPSTrafficOnly != nil {
+ objectMap["supportsHttpsTrafficOnly"] = ap.EnableHTTPSTrafficOnly
+ }
+ return json.Marshal(objectMap)
+}
+
+// AccountPropertiesCreateParameters the parameters used to create the storage account.
+type AccountPropertiesCreateParameters struct {
+ // CustomDomain - User domain assigned to the storage account. Name is the CNAME source. Only one custom domain is supported per storage account at this time. To clear the existing custom domain, use an empty string for the custom domain name property.
+ CustomDomain *CustomDomain `json:"customDomain,omitempty"`
+ // Encryption - Provides the encryption settings on the account. If left unspecified the account encryption settings will remain the same. The default setting is unencrypted.
+ Encryption *Encryption `json:"encryption,omitempty"`
+ // NetworkRuleSet - Network rule set
+ NetworkRuleSet *NetworkRuleSet `json:"networkAcls,omitempty"`
+ // AccessTier - Required for storage accounts where kind = BlobStorage. The access tier used for billing. Possible values include: 'Hot', 'Cool'
+ AccessTier AccessTier `json:"accessTier,omitempty"`
+ // EnableHTTPSTrafficOnly - Allows https traffic only to storage service if sets to true.
+ EnableHTTPSTrafficOnly *bool `json:"supportsHttpsTrafficOnly,omitempty"`
+}
+
+// AccountPropertiesUpdateParameters the parameters used when updating a storage account.
+type AccountPropertiesUpdateParameters struct {
+ // CustomDomain - Custom domain assigned to the storage account by the user. Name is the CNAME source. Only one custom domain is supported per storage account at this time. To clear the existing custom domain, use an empty string for the custom domain name property.
+ CustomDomain *CustomDomain `json:"customDomain,omitempty"`
+ // Encryption - Provides the encryption settings on the account. The default setting is unencrypted.
+ Encryption *Encryption `json:"encryption,omitempty"`
+ // AccessTier - Required for storage accounts where kind = BlobStorage. The access tier used for billing. Possible values include: 'Hot', 'Cool'
+ AccessTier AccessTier `json:"accessTier,omitempty"`
+ // EnableHTTPSTrafficOnly - Allows https traffic only to storage service if sets to true.
+ EnableHTTPSTrafficOnly *bool `json:"supportsHttpsTrafficOnly,omitempty"`
+ // NetworkRuleSet - Network rule set
+ NetworkRuleSet *NetworkRuleSet `json:"networkAcls,omitempty"`
+}
+
+// AccountRegenerateKeyParameters the parameters used to regenerate the storage account key.
+type AccountRegenerateKeyParameters struct {
+ // KeyName - The name of storage keys that want to be regenerated, possible values are key1, key2.
+ KeyName *string `json:"keyName,omitempty"`
+}
+
+// AccountSasParameters the parameters to list SAS credentials of a storage account.
+type AccountSasParameters struct {
+ // Services - The signed services accessible with the account SAS. Possible values include: Blob (b), Queue (q), Table (t), File (f). Possible values include: 'B', 'Q', 'T', 'F'
+ Services Services `json:"signedServices,omitempty"`
+ // ResourceTypes - The signed resource types that are accessible with the account SAS. Service (s): Access to service-level APIs; Container (c): Access to container-level APIs; Object (o): Access to object-level APIs for blobs, queue messages, table entities, and files. Possible values include: 'SignedResourceTypesS', 'SignedResourceTypesC', 'SignedResourceTypesO'
+ ResourceTypes SignedResourceTypes `json:"signedResourceTypes,omitempty"`
+ // Permissions - The signed permissions for the account SAS. Possible values include: Read (r), Write (w), Delete (d), List (l), Add (a), Create (c), Update (u) and Process (p). Possible values include: 'R', 'D', 'W', 'L', 'A', 'C', 'U', 'P'
+ Permissions Permissions `json:"signedPermission,omitempty"`
+ // IPAddressOrRange - An IP address or a range of IP addresses from which to accept requests.
+ IPAddressOrRange *string `json:"signedIp,omitempty"`
+ // Protocols - The protocol permitted for a request made with the account SAS. Possible values include: 'Httpshttp', 'HTTPS'
+ Protocols HTTPProtocol `json:"signedProtocol,omitempty"`
+ // SharedAccessStartTime - The time at which the SAS becomes valid.
+ SharedAccessStartTime *date.Time `json:"signedStart,omitempty"`
+ // SharedAccessExpiryTime - The time at which the shared access signature becomes invalid.
+ SharedAccessExpiryTime *date.Time `json:"signedExpiry,omitempty"`
+ // KeyToSign - The key to sign the account SAS token with.
+ KeyToSign *string `json:"keyToSign,omitempty"`
+}
+
+// AccountsCreateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type AccountsCreateFuture struct {
+ azure.FutureAPI
+ // Result returns the result of the asynchronous operation.
+ // If the operation has not completed it will return an error.
+ Result func(AccountsClient) (Account, error)
+}
+
+// AccountUpdateParameters the parameters that can be provided when updating the storage account
+// properties.
+type AccountUpdateParameters struct {
+ // Sku - Gets or sets the SKU name. Note that the SKU name cannot be updated to Standard_ZRS or Premium_LRS, nor can accounts of those sku names be updated to any other value.
+ Sku *Sku `json:"sku,omitempty"`
+ // Tags - Gets or sets a list of key value pairs that describe the resource. These tags can be used in viewing and grouping this resource (across resource groups). A maximum of 15 tags can be provided for a resource. Each tag must have a key no greater in length than 128 characters and a value no greater in length than 256 characters.
+ Tags map[string]*string `json:"tags"`
+ // Identity - The identity of the resource.
+ Identity *Identity `json:"identity,omitempty"`
+ // AccountPropertiesUpdateParameters - The parameters used when updating a storage account.
+ *AccountPropertiesUpdateParameters `json:"properties,omitempty"`
+ // Kind - Optional. Indicates the type of storage account. Currently only StorageV2 value supported by server. Possible values include: 'Storage', 'StorageV2', 'BlobStorage'
+ Kind Kind `json:"kind,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for AccountUpdateParameters.
+func (aup AccountUpdateParameters) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if aup.Sku != nil {
+ objectMap["sku"] = aup.Sku
+ }
+ if aup.Tags != nil {
+ objectMap["tags"] = aup.Tags
+ }
+ if aup.Identity != nil {
+ objectMap["identity"] = aup.Identity
+ }
+ if aup.AccountPropertiesUpdateParameters != nil {
+ objectMap["properties"] = aup.AccountPropertiesUpdateParameters
+ }
+ if aup.Kind != "" {
+ objectMap["kind"] = aup.Kind
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for AccountUpdateParameters struct.
+func (aup *AccountUpdateParameters) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ aup.Sku = &sku
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ aup.Tags = tags
+ }
+ case "identity":
+ if v != nil {
+ var identity Identity
+ err = json.Unmarshal(*v, &identity)
+ if err != nil {
+ return err
+ }
+ aup.Identity = &identity
+ }
+ case "properties":
+ if v != nil {
+ var accountPropertiesUpdateParameters AccountPropertiesUpdateParameters
+ err = json.Unmarshal(*v, &accountPropertiesUpdateParameters)
+ if err != nil {
+ return err
+ }
+ aup.AccountPropertiesUpdateParameters = &accountPropertiesUpdateParameters
+ }
+ case "kind":
+ if v != nil {
+ var kind Kind
+ err = json.Unmarshal(*v, &kind)
+ if err != nil {
+ return err
+ }
+ aup.Kind = kind
+ }
+ }
+ }
+
+ return nil
+}
+
+// CheckNameAvailabilityResult the CheckNameAvailability operation response.
+type CheckNameAvailabilityResult struct {
+ autorest.Response `json:"-"`
+ // NameAvailable - READ-ONLY; Gets a boolean value that indicates whether the name is available for you to use. If true, the name is available. If false, the name has already been taken or is invalid and cannot be used.
+ NameAvailable *bool `json:"nameAvailable,omitempty"`
+ // Reason - READ-ONLY; Gets the reason that a storage account name could not be used. The Reason element is only returned if NameAvailable is false. Possible values include: 'AccountNameInvalid', 'AlreadyExists'
+ Reason Reason `json:"reason,omitempty"`
+ // Message - READ-ONLY; Gets an error message explaining the Reason value in more detail.
+ Message *string `json:"message,omitempty"`
+}
+
+// CustomDomain the custom domain assigned to this storage account. This can be set via Update.
+type CustomDomain struct {
+ // Name - Gets or sets the custom domain name assigned to the storage account. Name is the CNAME source.
+ Name *string `json:"name,omitempty"`
+ // UseSubDomainName - Indicates whether indirect CName validation is enabled. Default value is false. This should only be set on updates.
+ UseSubDomainName *bool `json:"useSubDomainName,omitempty"`
+}
+
+// Dimension dimension of blobs, possibly be blob type or access tier.
+type Dimension struct {
+ // Name - Display name of dimension.
+ Name *string `json:"name,omitempty"`
+ // DisplayName - Display name of dimension.
+ DisplayName *string `json:"displayName,omitempty"`
+}
+
+// Encryption the encryption settings on the storage account.
+type Encryption struct {
+ // Services - List of services which support encryption.
+ Services *EncryptionServices `json:"services,omitempty"`
+ // KeySource - The encryption keySource (provider). Possible values (case-insensitive): Microsoft.Storage, Microsoft.Keyvault. Possible values include: 'MicrosoftStorage', 'MicrosoftKeyvault'
+ KeySource KeySource `json:"keySource,omitempty"`
+ // KeyVaultProperties - Properties provided by key vault.
+ KeyVaultProperties *KeyVaultProperties `json:"keyvaultproperties,omitempty"`
+}
+
+// EncryptionService a service that allows server-side encryption to be used.
+type EncryptionService struct {
+ // Enabled - A boolean indicating whether or not the service encrypts the data as it is stored.
+ Enabled *bool `json:"enabled,omitempty"`
+ // LastEnabledTime - READ-ONLY; Gets a rough estimate of the date/time when the encryption was last enabled by the user. Only returned when encryption is enabled. There might be some unencrypted blobs which were written after this time, as it is just a rough estimate.
+ LastEnabledTime *date.Time `json:"lastEnabledTime,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for EncryptionService.
+func (es EncryptionService) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if es.Enabled != nil {
+ objectMap["enabled"] = es.Enabled
+ }
+ return json.Marshal(objectMap)
+}
+
+// EncryptionServices a list of services that support encryption.
+type EncryptionServices struct {
+ // Blob - The encryption function of the blob storage service.
+ Blob *EncryptionService `json:"blob,omitempty"`
+ // File - The encryption function of the file storage service.
+ File *EncryptionService `json:"file,omitempty"`
+ // Table - READ-ONLY; The encryption function of the table storage service.
+ Table *EncryptionService `json:"table,omitempty"`
+ // Queue - READ-ONLY; The encryption function of the queue storage service.
+ Queue *EncryptionService `json:"queue,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for EncryptionServices.
+func (es EncryptionServices) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if es.Blob != nil {
+ objectMap["blob"] = es.Blob
+ }
+ if es.File != nil {
+ objectMap["file"] = es.File
+ }
+ return json.Marshal(objectMap)
+}
+
+// Endpoints the URIs that are used to perform a retrieval of a public blob, queue, or table object.
+type Endpoints struct {
+ // Blob - READ-ONLY; Gets the blob endpoint.
+ Blob *string `json:"blob,omitempty"`
+ // Queue - READ-ONLY; Gets the queue endpoint.
+ Queue *string `json:"queue,omitempty"`
+ // Table - READ-ONLY; Gets the table endpoint.
+ Table *string `json:"table,omitempty"`
+ // File - READ-ONLY; Gets the file endpoint.
+ File *string `json:"file,omitempty"`
+}
+
+// Identity identity for the resource.
+type Identity struct {
+ // PrincipalID - READ-ONLY; The principal ID of resource identity.
+ PrincipalID *string `json:"principalId,omitempty"`
+ // TenantID - READ-ONLY; The tenant ID of resource.
+ TenantID *string `json:"tenantId,omitempty"`
+ // Type - The identity type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Identity.
+func (i Identity) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if i.Type != nil {
+ objectMap["type"] = i.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// IPRule IP rule with specific IP or IP range in CIDR format.
+type IPRule struct {
+ // IPAddressOrRange - Specifies the IP or IP range in CIDR format. Only IPV4 address is allowed.
+ IPAddressOrRange *string `json:"value,omitempty"`
+ // Action - The action of IP ACL rule. Possible values include: 'Allow'
+ Action Action `json:"action,omitempty"`
+}
+
+// KeyVaultProperties properties of key vault.
+type KeyVaultProperties struct {
+ // KeyName - The name of KeyVault key.
+ KeyName *string `json:"keyname,omitempty"`
+ // KeyVersion - The version of KeyVault key.
+ KeyVersion *string `json:"keyversion,omitempty"`
+ // KeyVaultURI - The Uri of KeyVault.
+ KeyVaultURI *string `json:"keyvaulturi,omitempty"`
+}
+
+// ListAccountSasResponse the List SAS credentials operation response.
+type ListAccountSasResponse struct {
+ autorest.Response `json:"-"`
+ // AccountSasToken - READ-ONLY; List SAS credentials of storage account.
+ AccountSasToken *string `json:"accountSasToken,omitempty"`
+}
+
+// ListServiceSasResponse the List service SAS credentials operation response.
+type ListServiceSasResponse struct {
+ autorest.Response `json:"-"`
+ // ServiceSasToken - READ-ONLY; List service SAS credentials of specific resource.
+ ServiceSasToken *string `json:"serviceSasToken,omitempty"`
+}
+
+// MetricSpecification metric specification of operation.
+type MetricSpecification struct {
+ // Name - Name of metric specification.
+ Name *string `json:"name,omitempty"`
+ // DisplayName - Display name of metric specification.
+ DisplayName *string `json:"displayName,omitempty"`
+ // DisplayDescription - Display description of metric specification.
+ DisplayDescription *string `json:"displayDescription,omitempty"`
+ // Unit - Unit could be Bytes or Count.
+ Unit *string `json:"unit,omitempty"`
+ // Dimensions - Dimensions of blobs, including blob type and access tier.
+ Dimensions *[]Dimension `json:"dimensions,omitempty"`
+ // AggregationType - Aggregation type could be Average.
+ AggregationType *string `json:"aggregationType,omitempty"`
+ // FillGapWithZero - The property to decide fill gap with zero or not.
+ FillGapWithZero *bool `json:"fillGapWithZero,omitempty"`
+ // Category - The category this metric specification belong to, could be Capacity.
+ Category *string `json:"category,omitempty"`
+ // ResourceIDDimensionNameOverride - Account Resource Id.
+ ResourceIDDimensionNameOverride *string `json:"resourceIdDimensionNameOverride,omitempty"`
+}
+
+// NetworkRuleSet network rule set
+type NetworkRuleSet struct {
+ // Bypass - Specifies whether traffic is bypassed for Logging/Metrics/AzureServices. Possible values are any combination of Logging|Metrics|AzureServices (For example, "Logging, Metrics"), or None to bypass none of those traffics. Possible values include: 'None', 'Logging', 'Metrics', 'AzureServices'
+ Bypass Bypass `json:"bypass,omitempty"`
+ // VirtualNetworkRules - Sets the virtual network rules
+ VirtualNetworkRules *[]VirtualNetworkRule `json:"virtualNetworkRules,omitempty"`
+ // IPRules - Sets the IP ACL rules
+ IPRules *[]IPRule `json:"ipRules,omitempty"`
+ // DefaultAction - Specifies the default action of allow or deny when no other rules match. Possible values include: 'DefaultActionAllow', 'DefaultActionDeny'
+ DefaultAction DefaultAction `json:"defaultAction,omitempty"`
+}
+
+// Operation storage REST API operation definition.
+type Operation struct {
+ // Name - Operation name: {provider}/{resource}/{operation}
+ Name *string `json:"name,omitempty"`
+ // Display - Display metadata associated with the operation.
+ Display *OperationDisplay `json:"display,omitempty"`
+ // Origin - The origin of operations.
+ Origin *string `json:"origin,omitempty"`
+ // OperationProperties - Properties of operation, include metric specifications.
+ *OperationProperties `json:"properties,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Operation.
+func (o Operation) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if o.Name != nil {
+ objectMap["name"] = o.Name
+ }
+ if o.Display != nil {
+ objectMap["display"] = o.Display
+ }
+ if o.Origin != nil {
+ objectMap["origin"] = o.Origin
+ }
+ if o.OperationProperties != nil {
+ objectMap["properties"] = o.OperationProperties
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Operation struct.
+func (o *Operation) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ o.Name = &name
+ }
+ case "display":
+ if v != nil {
+ var display OperationDisplay
+ err = json.Unmarshal(*v, &display)
+ if err != nil {
+ return err
+ }
+ o.Display = &display
+ }
+ case "origin":
+ if v != nil {
+ var origin string
+ err = json.Unmarshal(*v, &origin)
+ if err != nil {
+ return err
+ }
+ o.Origin = &origin
+ }
+ case "properties":
+ if v != nil {
+ var operationProperties OperationProperties
+ err = json.Unmarshal(*v, &operationProperties)
+ if err != nil {
+ return err
+ }
+ o.OperationProperties = &operationProperties
+ }
+ }
+ }
+
+ return nil
+}
+
+// OperationDisplay display metadata associated with the operation.
+type OperationDisplay struct {
+ // Provider - Service provider: Microsoft Storage.
+ Provider *string `json:"provider,omitempty"`
+ // Resource - Resource on which the operation is performed etc.
+ Resource *string `json:"resource,omitempty"`
+ // Operation - Type of operation: get, read, delete, etc.
+ Operation *string `json:"operation,omitempty"`
+}
+
+// OperationListResult result of the request to list Storage operations. It contains a list of operations
+// and a URL link to get the next set of results.
+type OperationListResult struct {
+ autorest.Response `json:"-"`
+ // Value - List of Storage operations supported by the Storage resource provider.
+ Value *[]Operation `json:"value,omitempty"`
+}
+
+// OperationProperties properties of operation, include metric specifications.
+type OperationProperties struct {
+ // ServiceSpecification - One property of operation, include metric specifications.
+ ServiceSpecification *ServiceSpecification `json:"serviceSpecification,omitempty"`
+}
+
+// Resource describes a storage resource.
+type Resource struct {
+ // ID - READ-ONLY; Resource Id
+ ID *string `json:"id,omitempty"`
+ // Name - READ-ONLY; Resource name
+ Name *string `json:"name,omitempty"`
+ // Type - READ-ONLY; Resource type
+ Type *string `json:"type,omitempty"`
+ // Location - Resource location
+ Location *string `json:"location,omitempty"`
+ // Tags - Tags assigned to a resource; can be used for viewing and grouping a resource (across resource groups).
+ Tags map[string]*string `json:"tags"`
+}
+
+// MarshalJSON is the custom marshaler for Resource.
+func (r Resource) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if r.Location != nil {
+ objectMap["location"] = r.Location
+ }
+ if r.Tags != nil {
+ objectMap["tags"] = r.Tags
+ }
+ return json.Marshal(objectMap)
+}
+
+// Restriction the restriction because of which SKU cannot be used.
+type Restriction struct {
+ // Type - READ-ONLY; The type of restrictions. As of now only possible value for this is location.
+ Type *string `json:"type,omitempty"`
+ // Values - READ-ONLY; The value of restrictions. If the restriction type is set to location. This would be different locations where the SKU is restricted.
+ Values *[]string `json:"values,omitempty"`
+ // ReasonCode - The reason for the restriction. As of now this can be "QuotaId" or "NotAvailableForSubscription". Quota Id is set when the SKU has requiredQuotas parameter as the subscription does not belong to that quota. The "NotAvailableForSubscription" is related to capacity at DC. Possible values include: 'QuotaID', 'NotAvailableForSubscription'
+ ReasonCode ReasonCode `json:"reasonCode,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Restriction.
+func (r Restriction) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if r.ReasonCode != "" {
+ objectMap["reasonCode"] = r.ReasonCode
+ }
+ return json.Marshal(objectMap)
+}
+
+// ServiceSasParameters the parameters to list service SAS credentials of a specific resource.
+type ServiceSasParameters struct {
+ // CanonicalizedResource - The canonical path to the signed resource.
+ CanonicalizedResource *string `json:"canonicalizedResource,omitempty"`
+ // Resource - The signed services accessible with the service SAS. Possible values include: Blob (b), Container (c), File (f), Share (s). Possible values include: 'SignedResourceB', 'SignedResourceC', 'SignedResourceF', 'SignedResourceS'
+ Resource SignedResource `json:"signedResource,omitempty"`
+ // Permissions - The signed permissions for the service SAS. Possible values include: Read (r), Write (w), Delete (d), List (l), Add (a), Create (c), Update (u) and Process (p). Possible values include: 'R', 'D', 'W', 'L', 'A', 'C', 'U', 'P'
+ Permissions Permissions `json:"signedPermission,omitempty"`
+ // IPAddressOrRange - An IP address or a range of IP addresses from which to accept requests.
+ IPAddressOrRange *string `json:"signedIp,omitempty"`
+ // Protocols - The protocol permitted for a request made with the account SAS. Possible values include: 'Httpshttp', 'HTTPS'
+ Protocols HTTPProtocol `json:"signedProtocol,omitempty"`
+ // SharedAccessStartTime - The time at which the SAS becomes valid.
+ SharedAccessStartTime *date.Time `json:"signedStart,omitempty"`
+ // SharedAccessExpiryTime - The time at which the shared access signature becomes invalid.
+ SharedAccessExpiryTime *date.Time `json:"signedExpiry,omitempty"`
+ // Identifier - A unique value up to 64 characters in length that correlates to an access policy specified for the container, queue, or table.
+ Identifier *string `json:"signedIdentifier,omitempty"`
+ // PartitionKeyStart - The start of partition key.
+ PartitionKeyStart *string `json:"startPk,omitempty"`
+ // PartitionKeyEnd - The end of partition key.
+ PartitionKeyEnd *string `json:"endPk,omitempty"`
+ // RowKeyStart - The start of row key.
+ RowKeyStart *string `json:"startRk,omitempty"`
+ // RowKeyEnd - The end of row key.
+ RowKeyEnd *string `json:"endRk,omitempty"`
+ // KeyToSign - The key to sign the account SAS token with.
+ KeyToSign *string `json:"keyToSign,omitempty"`
+ // CacheControl - The response header override for cache control.
+ CacheControl *string `json:"rscc,omitempty"`
+ // ContentDisposition - The response header override for content disposition.
+ ContentDisposition *string `json:"rscd,omitempty"`
+ // ContentEncoding - The response header override for content encoding.
+ ContentEncoding *string `json:"rsce,omitempty"`
+ // ContentLanguage - The response header override for content language.
+ ContentLanguage *string `json:"rscl,omitempty"`
+ // ContentType - The response header override for content type.
+ ContentType *string `json:"rsct,omitempty"`
+}
+
+// ServiceSpecification one property of operation, include metric specifications.
+type ServiceSpecification struct {
+ // MetricSpecifications - Metric specifications of operation.
+ MetricSpecifications *[]MetricSpecification `json:"metricSpecifications,omitempty"`
+}
+
+// Sku the SKU of the storage account.
+type Sku struct {
+ // Name - Gets or sets the sku name. Required for account creation; optional for update. Note that in older versions, sku name was called accountType. Possible values include: 'StandardLRS', 'StandardGRS', 'StandardRAGRS', 'StandardZRS', 'PremiumLRS'
+ Name SkuName `json:"name,omitempty"`
+ // Tier - READ-ONLY; Gets the sku tier. This is based on the SKU name. Possible values include: 'Standard', 'Premium'
+ Tier SkuTier `json:"tier,omitempty"`
+ // ResourceType - READ-ONLY; The type of the resource, usually it is 'storageAccounts'.
+ ResourceType *string `json:"resourceType,omitempty"`
+ // Kind - READ-ONLY; Indicates the type of storage account. Possible values include: 'Storage', 'StorageV2', 'BlobStorage'
+ Kind Kind `json:"kind,omitempty"`
+ // Locations - READ-ONLY; The set of locations that the SKU is available. This will be supported and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia, etc.).
+ Locations *[]string `json:"locations,omitempty"`
+ // Capabilities - READ-ONLY; The capability information in the specified sku, including file encryption, network acls, change notification, etc.
+ Capabilities *[]SKUCapability `json:"capabilities,omitempty"`
+ // Restrictions - The restrictions because of which SKU cannot be used. This is empty if there are no restrictions.
+ Restrictions *[]Restriction `json:"restrictions,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Sku.
+func (s Sku) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if s.Name != "" {
+ objectMap["name"] = s.Name
+ }
+ if s.Restrictions != nil {
+ objectMap["restrictions"] = s.Restrictions
+ }
+ return json.Marshal(objectMap)
+}
+
+// SKUCapability the capability information in the specified sku, including file encryption, network acls,
+// change notification, etc.
+type SKUCapability struct {
+ // Name - READ-ONLY; The name of capability, The capability information in the specified sku, including file encryption, network acls, change notification, etc.
+ Name *string `json:"name,omitempty"`
+ // Value - READ-ONLY; A string value to indicate states of given capability. Possibly 'true' or 'false'.
+ Value *string `json:"value,omitempty"`
+}
+
+// SkuListResult the response from the List Storage SKUs operation.
+type SkuListResult struct {
+ autorest.Response `json:"-"`
+ // Value - READ-ONLY; Get the list result of storage SKUs and their properties.
+ Value *[]Sku `json:"value,omitempty"`
+}
+
+// Usage describes Storage Resource Usage.
+type Usage struct {
+ // Unit - READ-ONLY; Gets the unit of measurement. Possible values include: 'Count', 'Bytes', 'Seconds', 'Percent', 'CountsPerSecond', 'BytesPerSecond'
+ Unit UsageUnit `json:"unit,omitempty"`
+ // CurrentValue - READ-ONLY; Gets the current count of the allocated resources in the subscription.
+ CurrentValue *int32 `json:"currentValue,omitempty"`
+ // Limit - READ-ONLY; Gets the maximum count of the resources that can be allocated in the subscription.
+ Limit *int32 `json:"limit,omitempty"`
+ // Name - READ-ONLY; Gets the name of the type of usage.
+ Name *UsageName `json:"name,omitempty"`
+}
+
+// UsageListResult the response from the List Usages operation.
+type UsageListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Gets or sets the list of Storage Resource Usages.
+ Value *[]Usage `json:"value,omitempty"`
+}
+
+// UsageName the usage names that can be used; currently limited to StorageAccount.
+type UsageName struct {
+ // Value - READ-ONLY; Gets a string describing the resource name.
+ Value *string `json:"value,omitempty"`
+ // LocalizedValue - READ-ONLY; Gets a localized string describing the resource name.
+ LocalizedValue *string `json:"localizedValue,omitempty"`
+}
+
+// VirtualNetworkRule virtual Network rule.
+type VirtualNetworkRule struct {
+ // VirtualNetworkResourceID - Resource ID of a subnet, for example: /subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{vnetName}/subnets/{subnetName}.
+ VirtualNetworkResourceID *string `json:"id,omitempty"`
+ // Action - The action of virtual network rule. Possible values include: 'Allow'
+ Action Action `json:"action,omitempty"`
+ // State - Gets the state of virtual network rule. Possible values include: 'StateProvisioning', 'StateDeprovisioning', 'StateSucceeded', 'StateFailed', 'StateNetworkSourceDeleted'
+ State State `json:"state,omitempty"`
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/operations.go
new file mode 100644
index 00000000000..e093a1a5752
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/operations.go
@@ -0,0 +1,109 @@
+package storage
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// OperationsClient is the the Azure Storage Management API.
+type OperationsClient struct {
+ BaseClient
+}
+
+// NewOperationsClient creates an instance of the OperationsClient client.
+func NewOperationsClient(subscriptionID string) OperationsClient {
+ return NewOperationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewOperationsClientWithBaseURI creates an instance of the OperationsClient client using a custom endpoint. Use this
+// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+ return OperationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List lists all of the available Storage Rest API operations.
+func (client OperationsClient) List(ctx context.Context) (result OperationListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.OperationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.OperationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.OperationsClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Storage/operations"),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client OperationsClient) ListResponder(resp *http.Response) (result OperationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/skus.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/skus.go
new file mode 100644
index 00000000000..0c7fc62f5a4
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/skus.go
@@ -0,0 +1,113 @@
+package storage
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// SkusClient is the the Azure Storage Management API.
+type SkusClient struct {
+ BaseClient
+}
+
+// NewSkusClient creates an instance of the SkusClient client.
+func NewSkusClient(subscriptionID string) SkusClient {
+ return NewSkusClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewSkusClientWithBaseURI creates an instance of the SkusClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewSkusClientWithBaseURI(baseURI string, subscriptionID string) SkusClient {
+ return SkusClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List lists the available SKUs supported by Microsoft.Storage for given subscription.
+func (client SkusClient) List(ctx context.Context) (result SkuListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/SkusClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.SkusClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.SkusClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.SkusClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client SkusClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/skus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client SkusClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client SkusClient) ListResponder(resp *http.Response) (result SkuListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/usage.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/usage.go
new file mode 100644
index 00000000000..0613cecf883
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/usage.go
@@ -0,0 +1,113 @@
+package storage
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/tracing"
+ "net/http"
+)
+
+// UsageClient is the the Azure Storage Management API.
+type UsageClient struct {
+ BaseClient
+}
+
+// NewUsageClient creates an instance of the UsageClient client.
+func NewUsageClient(subscriptionID string) UsageClient {
+ return NewUsageClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewUsageClientWithBaseURI creates an instance of the UsageClient client using a custom endpoint. Use this when
+// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
+func NewUsageClientWithBaseURI(baseURI string, subscriptionID string) UsageClient {
+ return UsageClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List gets the current usage count and the limit for the resources under the subscription.
+func (client UsageClient) List(ctx context.Context) (result UsageListResult, err error) {
+ if tracing.IsEnabled() {
+ ctx = tracing.StartSpan(ctx, fqdn+"/UsageClient.List")
+ defer func() {
+ sc := -1
+ if result.Response.Response != nil {
+ sc = result.Response.Response.StatusCode
+ }
+ tracing.EndSpan(ctx, sc, err)
+ }()
+ }
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.UsageClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "storage.UsageClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "storage.UsageClient", "List", resp, "Failure responding to request")
+ return
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client UsageClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-10-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client UsageClient) ListSender(req *http.Request) (*http.Response, error) {
+ return client.Send(req, azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client UsageClient) ListResponder(resp *http.Response) (result UsageListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/version.go b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/version.go
new file mode 100644
index 00000000000..1d0bf09b3e3
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage/version.go
@@ -0,0 +1,30 @@
+package storage
+
+import "github.com/Azure/azure-sdk-for-go/version"
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// UserAgent returns the UserAgent string to use when sending http.Requests.
+func UserAgent() string {
+ return "Azure-SDK-For-Go/" + Version() + " storage/2017-10-01"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+ return version.Number
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/README.md b/vendor/github.com/Azure/azure-sdk-for-go/storage/README.md
new file mode 100644
index 00000000000..16f5dad1992
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/README.md
@@ -0,0 +1,22 @@
+# Azure Storage SDK for Go (Preview)
+
+:exclamation: IMPORTANT: This package is in maintenance only and will be deprecated in the
+future. Please use one of the following packages instead.
+
+| Service | Import Path/Repo |
+|---------|------------------|
+| Storage - Blobs | [github.com/Azure/azure-storage-blob-go](https://github.com/Azure/azure-storage-blob-go) |
+| Storage - Files | [github.com/Azure/azure-storage-file-go](https://github.com/Azure/azure-storage-file-go) |
+| Storage - Queues | [github.com/Azure/azure-storage-queue-go](https://github.com/Azure/azure-storage-queue-go) |
+
+The `github.com/Azure/azure-sdk-for-go/storage` package is used to manage
+[Azure Storage](https://docs.microsoft.com/azure/storage/) data plane
+resources: containers, blobs, tables, and queues.
+
+To manage storage *accounts* use Azure Resource Manager (ARM) via the packages
+at [github.com/Azure/azure-sdk-for-go/services/storage](https://github.com/Azure/azure-sdk-for-go/tree/master/services/storage).
+
+This package also supports the [Azure Storage
+Emulator](https://azure.microsoft.com/documentation/articles/storage-use-emulator/)
+(Windows only).
+
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/appendblob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/appendblob.go
new file mode 100644
index 00000000000..8b5b96d4884
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/appendblob.go
@@ -0,0 +1,91 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bytes"
+ "crypto/md5"
+ "encoding/base64"
+ "fmt"
+ "net/http"
+ "net/url"
+ "time"
+)
+
+// PutAppendBlob initializes an empty append blob with specified name. An
+// append blob must be created using this method before appending blocks.
+//
+// See CreateBlockBlobFromReader for more info on creating blobs.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Blob
+func (b *Blob) PutAppendBlob(options *PutBlobOptions) error {
+ params := url.Values{}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypeAppend)
+ headers = mergeHeaders(headers, headersFromStruct(b.Properties))
+ headers = b.Container.bsc.client.addMetadataToHeaders(headers, b.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ return b.respondCreation(resp, BlobTypeAppend)
+}
+
+// AppendBlockOptions includes the options for an append block operation
+type AppendBlockOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ MaxSize *uint `header:"x-ms-blob-condition-maxsize"`
+ AppendPosition *uint `header:"x-ms-blob-condition-appendpos"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+ ContentMD5 bool
+}
+
+// AppendBlock appends a block to an append blob.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Append-Block
+func (b *Blob) AppendBlock(chunk []byte, options *AppendBlockOptions) error {
+ params := url.Values{"comp": {"appendblock"}}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypeAppend)
+ headers["Content-Length"] = fmt.Sprintf("%v", len(chunk))
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ if options.ContentMD5 {
+ md5sum := md5.Sum(chunk)
+ headers[headerContentMD5] = base64.StdEncoding.EncodeToString(md5sum[:])
+ }
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, bytes.NewReader(chunk), b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ return b.respondCreation(resp, BlobTypeAppend)
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/authorization.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/authorization.go
new file mode 100644
index 00000000000..76794c30518
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/authorization.go
@@ -0,0 +1,246 @@
+// Package storage provides clients for Microsoft Azure Storage Services.
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bytes"
+ "fmt"
+ "net/url"
+ "sort"
+ "strings"
+)
+
+// See: https://docs.microsoft.com/rest/api/storageservices/fileservices/authentication-for-the-azure-storage-services
+
+type authentication string
+
+const (
+ sharedKey authentication = "sharedKey"
+ sharedKeyForTable authentication = "sharedKeyTable"
+ sharedKeyLite authentication = "sharedKeyLite"
+ sharedKeyLiteForTable authentication = "sharedKeyLiteTable"
+
+ // headers
+ headerAcceptCharset = "Accept-Charset"
+ headerAuthorization = "Authorization"
+ headerContentLength = "Content-Length"
+ headerDate = "Date"
+ headerXmsDate = "x-ms-date"
+ headerXmsVersion = "x-ms-version"
+ headerContentEncoding = "Content-Encoding"
+ headerContentLanguage = "Content-Language"
+ headerContentType = "Content-Type"
+ headerContentMD5 = "Content-MD5"
+ headerIfModifiedSince = "If-Modified-Since"
+ headerIfMatch = "If-Match"
+ headerIfNoneMatch = "If-None-Match"
+ headerIfUnmodifiedSince = "If-Unmodified-Since"
+ headerRange = "Range"
+ headerDataServiceVersion = "DataServiceVersion"
+ headerMaxDataServiceVersion = "MaxDataServiceVersion"
+ headerContentTransferEncoding = "Content-Transfer-Encoding"
+)
+
+func (c *Client) addAuthorizationHeader(verb, url string, headers map[string]string, auth authentication) (map[string]string, error) {
+ if !c.sasClient {
+ authHeader, err := c.getSharedKey(verb, url, headers, auth)
+ if err != nil {
+ return nil, err
+ }
+ headers[headerAuthorization] = authHeader
+ }
+ return headers, nil
+}
+
+func (c *Client) getSharedKey(verb, url string, headers map[string]string, auth authentication) (string, error) {
+ canRes, err := c.buildCanonicalizedResource(url, auth, false)
+ if err != nil {
+ return "", err
+ }
+
+ canString, err := buildCanonicalizedString(verb, headers, canRes, auth)
+ if err != nil {
+ return "", err
+ }
+ return c.createAuthorizationHeader(canString, auth), nil
+}
+
+func (c *Client) buildCanonicalizedResource(uri string, auth authentication, sas bool) (string, error) {
+ errMsg := "buildCanonicalizedResource error: %s"
+ u, err := url.Parse(uri)
+ if err != nil {
+ return "", fmt.Errorf(errMsg, err.Error())
+ }
+
+ cr := bytes.NewBufferString("")
+ if c.accountName != StorageEmulatorAccountName || !sas {
+ cr.WriteString("/")
+ cr.WriteString(c.getCanonicalizedAccountName())
+ }
+
+ if len(u.Path) > 0 {
+ // Any portion of the CanonicalizedResource string that is derived from
+ // the resource's URI should be encoded exactly as it is in the URI.
+ // -- https://msdn.microsoft.com/en-gb/library/azure/dd179428.aspx
+ cr.WriteString(u.EscapedPath())
+ }
+
+ params, err := url.ParseQuery(u.RawQuery)
+ if err != nil {
+ return "", fmt.Errorf(errMsg, err.Error())
+ }
+
+ // See https://github.com/Azure/azure-storage-net/blob/master/Lib/Common/Core/Util/AuthenticationUtility.cs#L277
+ if auth == sharedKey {
+ if len(params) > 0 {
+ cr.WriteString("\n")
+
+ keys := []string{}
+ for key := range params {
+ keys = append(keys, key)
+ }
+ sort.Strings(keys)
+
+ completeParams := []string{}
+ for _, key := range keys {
+ if len(params[key]) > 1 {
+ sort.Strings(params[key])
+ }
+
+ completeParams = append(completeParams, fmt.Sprintf("%s:%s", key, strings.Join(params[key], ",")))
+ }
+ cr.WriteString(strings.Join(completeParams, "\n"))
+ }
+ } else {
+ // search for "comp" parameter, if exists then add it to canonicalizedresource
+ if v, ok := params["comp"]; ok {
+ cr.WriteString("?comp=" + v[0])
+ }
+ }
+
+ return string(cr.Bytes()), nil
+}
+
+func (c *Client) getCanonicalizedAccountName() string {
+ // since we may be trying to access a secondary storage account, we need to
+ // remove the -secondary part of the storage name
+ return strings.TrimSuffix(c.accountName, "-secondary")
+}
+
+func buildCanonicalizedString(verb string, headers map[string]string, canonicalizedResource string, auth authentication) (string, error) {
+ contentLength := headers[headerContentLength]
+ if contentLength == "0" {
+ contentLength = ""
+ }
+ date := headers[headerDate]
+ if v, ok := headers[headerXmsDate]; ok {
+ if auth == sharedKey || auth == sharedKeyLite {
+ date = ""
+ } else {
+ date = v
+ }
+ }
+ var canString string
+ switch auth {
+ case sharedKey:
+ canString = strings.Join([]string{
+ verb,
+ headers[headerContentEncoding],
+ headers[headerContentLanguage],
+ contentLength,
+ headers[headerContentMD5],
+ headers[headerContentType],
+ date,
+ headers[headerIfModifiedSince],
+ headers[headerIfMatch],
+ headers[headerIfNoneMatch],
+ headers[headerIfUnmodifiedSince],
+ headers[headerRange],
+ buildCanonicalizedHeader(headers),
+ canonicalizedResource,
+ }, "\n")
+ case sharedKeyForTable:
+ canString = strings.Join([]string{
+ verb,
+ headers[headerContentMD5],
+ headers[headerContentType],
+ date,
+ canonicalizedResource,
+ }, "\n")
+ case sharedKeyLite:
+ canString = strings.Join([]string{
+ verb,
+ headers[headerContentMD5],
+ headers[headerContentType],
+ date,
+ buildCanonicalizedHeader(headers),
+ canonicalizedResource,
+ }, "\n")
+ case sharedKeyLiteForTable:
+ canString = strings.Join([]string{
+ date,
+ canonicalizedResource,
+ }, "\n")
+ default:
+ return "", fmt.Errorf("%s authentication is not supported yet", auth)
+ }
+ return canString, nil
+}
+
+func buildCanonicalizedHeader(headers map[string]string) string {
+ cm := make(map[string]string)
+
+ for k, v := range headers {
+ headerName := strings.TrimSpace(strings.ToLower(k))
+ if strings.HasPrefix(headerName, "x-ms-") {
+ cm[headerName] = v
+ }
+ }
+
+ if len(cm) == 0 {
+ return ""
+ }
+
+ keys := []string{}
+ for key := range cm {
+ keys = append(keys, key)
+ }
+
+ sort.Strings(keys)
+
+ ch := bytes.NewBufferString("")
+
+ for _, key := range keys {
+ ch.WriteString(key)
+ ch.WriteRune(':')
+ ch.WriteString(cm[key])
+ ch.WriteRune('\n')
+ }
+
+ return strings.TrimSuffix(string(ch.Bytes()), "\n")
+}
+
+func (c *Client) createAuthorizationHeader(canonicalizedString string, auth authentication) string {
+ signature := c.computeHmac256(canonicalizedString)
+ var key string
+ switch auth {
+ case sharedKey, sharedKeyForTable:
+ key = "SharedKey"
+ case sharedKeyLite, sharedKeyLiteForTable:
+ key = "SharedKeyLite"
+ }
+ return fmt.Sprintf("%s %s:%s", key, c.getCanonicalizedAccountName(), signature)
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/blob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/blob.go
new file mode 100644
index 00000000000..0b02e52bd7a
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/blob.go
@@ -0,0 +1,632 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// A Blob is an entry in BlobListResponse.
+type Blob struct {
+ Container *Container
+ Name string `xml:"Name"`
+ Snapshot time.Time `xml:"Snapshot"`
+ Properties BlobProperties `xml:"Properties"`
+ Metadata BlobMetadata `xml:"Metadata"`
+}
+
+// PutBlobOptions includes the options any put blob operation
+// (page, block, append)
+type PutBlobOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ Origin string `header:"Origin"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// BlobMetadata is a set of custom name/value pairs.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179404.aspx
+type BlobMetadata map[string]string
+
+type blobMetadataEntries struct {
+ Entries []blobMetadataEntry `xml:",any"`
+}
+type blobMetadataEntry struct {
+ XMLName xml.Name
+ Value string `xml:",chardata"`
+}
+
+// UnmarshalXML converts the xml:Metadata into Metadata map
+func (bm *BlobMetadata) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+ var entries blobMetadataEntries
+ if err := d.DecodeElement(&entries, &start); err != nil {
+ return err
+ }
+ for _, entry := range entries.Entries {
+ if *bm == nil {
+ *bm = make(BlobMetadata)
+ }
+ (*bm)[strings.ToLower(entry.XMLName.Local)] = entry.Value
+ }
+ return nil
+}
+
+// MarshalXML implements the xml.Marshaler interface. It encodes
+// metadata name/value pairs as they would appear in an Azure
+// ListBlobs response.
+func (bm BlobMetadata) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {
+ entries := make([]blobMetadataEntry, 0, len(bm))
+ for k, v := range bm {
+ entries = append(entries, blobMetadataEntry{
+ XMLName: xml.Name{Local: http.CanonicalHeaderKey(k)},
+ Value: v,
+ })
+ }
+ return enc.EncodeElement(blobMetadataEntries{
+ Entries: entries,
+ }, start)
+}
+
+// BlobProperties contains various properties of a blob
+// returned in various endpoints like ListBlobs or GetBlobProperties.
+type BlobProperties struct {
+ LastModified TimeRFC1123 `xml:"Last-Modified"`
+ Etag string `xml:"Etag"`
+ ContentMD5 string `xml:"Content-MD5" header:"x-ms-blob-content-md5"`
+ ContentLength int64 `xml:"Content-Length"`
+ ContentType string `xml:"Content-Type" header:"x-ms-blob-content-type"`
+ ContentEncoding string `xml:"Content-Encoding" header:"x-ms-blob-content-encoding"`
+ CacheControl string `xml:"Cache-Control" header:"x-ms-blob-cache-control"`
+ ContentLanguage string `xml:"Cache-Language" header:"x-ms-blob-content-language"`
+ ContentDisposition string `xml:"Content-Disposition" header:"x-ms-blob-content-disposition"`
+ BlobType BlobType `xml:"BlobType"`
+ SequenceNumber int64 `xml:"x-ms-blob-sequence-number"`
+ CopyID string `xml:"CopyId"`
+ CopyStatus string `xml:"CopyStatus"`
+ CopySource string `xml:"CopySource"`
+ CopyProgress string `xml:"CopyProgress"`
+ CopyCompletionTime TimeRFC1123 `xml:"CopyCompletionTime"`
+ CopyStatusDescription string `xml:"CopyStatusDescription"`
+ LeaseStatus string `xml:"LeaseStatus"`
+ LeaseState string `xml:"LeaseState"`
+ LeaseDuration string `xml:"LeaseDuration"`
+ ServerEncrypted bool `xml:"ServerEncrypted"`
+ IncrementalCopy bool `xml:"IncrementalCopy"`
+}
+
+// BlobType defines the type of the Azure Blob.
+type BlobType string
+
+// Types of page blobs
+const (
+ BlobTypeBlock BlobType = "BlockBlob"
+ BlobTypePage BlobType = "PageBlob"
+ BlobTypeAppend BlobType = "AppendBlob"
+)
+
+func (b *Blob) buildPath() string {
+ return b.Container.buildPath() + "/" + b.Name
+}
+
+// Exists returns true if a blob with given name exists on the specified
+// container of the storage account.
+func (b *Blob) Exists() (bool, error) {
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), nil)
+ headers := b.Container.bsc.client.getStandardHeaders()
+ resp, err := b.Container.bsc.client.exec(http.MethodHead, uri, headers, nil, b.Container.bsc.auth)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusOK, nil
+ }
+ }
+ return false, err
+}
+
+// GetURL gets the canonical URL to the blob with the specified name in the
+// specified container.
+// This method does not create a publicly accessible URL if the blob or container
+// is private and this method does not check if the blob exists.
+func (b *Blob) GetURL() string {
+ container := b.Container.Name
+ if container == "" {
+ container = "$root"
+ }
+ return b.Container.bsc.client.getEndpoint(blobServiceName, pathForResource(container, b.Name), nil)
+}
+
+// GetBlobRangeOptions includes the options for a get blob range operation
+type GetBlobRangeOptions struct {
+ Range *BlobRange
+ GetRangeContentMD5 bool
+ *GetBlobOptions
+}
+
+// GetBlobOptions includes the options for a get blob operation
+type GetBlobOptions struct {
+ Timeout uint
+ Snapshot *time.Time
+ LeaseID string `header:"x-ms-lease-id"`
+ Origin string `header:"Origin"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// BlobRange represents the bytes range to be get
+type BlobRange struct {
+ Start uint64
+ End uint64
+}
+
+func (br BlobRange) String() string {
+ if br.End == 0 {
+ return fmt.Sprintf("bytes=%d-", br.Start)
+ }
+ return fmt.Sprintf("bytes=%d-%d", br.Start, br.End)
+}
+
+// Get returns a stream to read the blob. Caller must call both Read and Close()
+// to correctly close the underlying connection.
+//
+// See the GetRange method for use with a Range header.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Get-Blob
+func (b *Blob) Get(options *GetBlobOptions) (io.ReadCloser, error) {
+ rangeOptions := GetBlobRangeOptions{
+ GetBlobOptions: options,
+ }
+ resp, err := b.getRange(&rangeOptions)
+ if err != nil {
+ return nil, err
+ }
+
+ if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+ if err := b.writeProperties(resp.Header, true); err != nil {
+ return resp.Body, err
+ }
+ return resp.Body, nil
+}
+
+// GetRange reads the specified range of a blob to a stream. The bytesRange
+// string must be in a format like "0-", "10-100" as defined in HTTP 1.1 spec.
+// Caller must call both Read and Close()// to correctly close the underlying
+// connection.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Get-Blob
+func (b *Blob) GetRange(options *GetBlobRangeOptions) (io.ReadCloser, error) {
+ resp, err := b.getRange(options)
+ if err != nil {
+ return nil, err
+ }
+
+ if err := checkRespCode(resp, []int{http.StatusPartialContent}); err != nil {
+ return nil, err
+ }
+ // Content-Length header should not be updated, as the service returns the range length
+ // (which is not alwys the full blob length)
+ if err := b.writeProperties(resp.Header, false); err != nil {
+ return resp.Body, err
+ }
+ return resp.Body, nil
+}
+
+func (b *Blob) getRange(options *GetBlobRangeOptions) (*http.Response, error) {
+ params := url.Values{}
+ headers := b.Container.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ if options.Range != nil {
+ headers["Range"] = options.Range.String()
+ if options.GetRangeContentMD5 {
+ headers["x-ms-range-get-content-md5"] = "true"
+ }
+ }
+ if options.GetBlobOptions != nil {
+ headers = mergeHeaders(headers, headersFromStruct(*options.GetBlobOptions))
+ params = addTimeout(params, options.Timeout)
+ params = addSnapshot(params, options.Snapshot)
+ }
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodGet, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return nil, err
+ }
+ return resp, err
+}
+
+// SnapshotOptions includes the options for a snapshot blob operation
+type SnapshotOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// CreateSnapshot creates a snapshot for a blob
+// See https://msdn.microsoft.com/en-us/library/azure/ee691971.aspx
+func (b *Blob) CreateSnapshot(options *SnapshotOptions) (snapshotTimestamp *time.Time, err error) {
+ params := url.Values{"comp": {"snapshot"}}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers = b.Container.bsc.client.addMetadataToHeaders(headers, b.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil || resp == nil {
+ return nil, err
+ }
+ defer drainRespBody(resp)
+
+ if err := checkRespCode(resp, []int{http.StatusCreated}); err != nil {
+ return nil, err
+ }
+
+ snapshotResponse := resp.Header.Get(http.CanonicalHeaderKey("x-ms-snapshot"))
+ if snapshotResponse != "" {
+ snapshotTimestamp, err := time.Parse(time.RFC3339, snapshotResponse)
+ if err != nil {
+ return nil, err
+ }
+ return &snapshotTimestamp, nil
+ }
+
+ return nil, errors.New("Snapshot not created")
+}
+
+// GetBlobPropertiesOptions includes the options for a get blob properties operation
+type GetBlobPropertiesOptions struct {
+ Timeout uint
+ Snapshot *time.Time
+ LeaseID string `header:"x-ms-lease-id"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// GetProperties provides various information about the specified blob.
+// See https://msdn.microsoft.com/en-us/library/azure/dd179394.aspx
+func (b *Blob) GetProperties(options *GetBlobPropertiesOptions) error {
+ params := url.Values{}
+ headers := b.Container.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ params = addSnapshot(params, options.Snapshot)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodHead, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return err
+ }
+ return b.writeProperties(resp.Header, true)
+}
+
+func (b *Blob) writeProperties(h http.Header, includeContentLen bool) error {
+ var err error
+
+ contentLength := b.Properties.ContentLength
+ if includeContentLen {
+ contentLengthStr := h.Get("Content-Length")
+ if contentLengthStr != "" {
+ contentLength, err = strconv.ParseInt(contentLengthStr, 0, 64)
+ if err != nil {
+ return err
+ }
+ }
+ }
+
+ var sequenceNum int64
+ sequenceNumStr := h.Get("x-ms-blob-sequence-number")
+ if sequenceNumStr != "" {
+ sequenceNum, err = strconv.ParseInt(sequenceNumStr, 0, 64)
+ if err != nil {
+ return err
+ }
+ }
+
+ lastModified, err := getTimeFromHeaders(h, "Last-Modified")
+ if err != nil {
+ return err
+ }
+
+ copyCompletionTime, err := getTimeFromHeaders(h, "x-ms-copy-completion-time")
+ if err != nil {
+ return err
+ }
+
+ b.Properties = BlobProperties{
+ LastModified: TimeRFC1123(*lastModified),
+ Etag: h.Get("Etag"),
+ ContentMD5: h.Get("Content-MD5"),
+ ContentLength: contentLength,
+ ContentEncoding: h.Get("Content-Encoding"),
+ ContentType: h.Get("Content-Type"),
+ ContentDisposition: h.Get("Content-Disposition"),
+ CacheControl: h.Get("Cache-Control"),
+ ContentLanguage: h.Get("Content-Language"),
+ SequenceNumber: sequenceNum,
+ CopyCompletionTime: TimeRFC1123(*copyCompletionTime),
+ CopyStatusDescription: h.Get("x-ms-copy-status-description"),
+ CopyID: h.Get("x-ms-copy-id"),
+ CopyProgress: h.Get("x-ms-copy-progress"),
+ CopySource: h.Get("x-ms-copy-source"),
+ CopyStatus: h.Get("x-ms-copy-status"),
+ BlobType: BlobType(h.Get("x-ms-blob-type")),
+ LeaseStatus: h.Get("x-ms-lease-status"),
+ LeaseState: h.Get("x-ms-lease-state"),
+ }
+ b.writeMetadata(h)
+ return nil
+}
+
+// SetBlobPropertiesOptions contains various properties of a blob and is an entry
+// in SetProperties
+type SetBlobPropertiesOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ Origin string `header:"Origin"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ SequenceNumberAction *SequenceNumberAction
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// SequenceNumberAction defines how the blob's sequence number should be modified
+type SequenceNumberAction string
+
+// Options for sequence number action
+const (
+ SequenceNumberActionMax SequenceNumberAction = "max"
+ SequenceNumberActionUpdate SequenceNumberAction = "update"
+ SequenceNumberActionIncrement SequenceNumberAction = "increment"
+)
+
+// SetProperties replaces the BlobHeaders for the specified blob.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetBlobProperties. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-Blob-Properties
+func (b *Blob) SetProperties(options *SetBlobPropertiesOptions) error {
+ params := url.Values{"comp": {"properties"}}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers = mergeHeaders(headers, headersFromStruct(b.Properties))
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ if b.Properties.BlobType == BlobTypePage {
+ headers = addToHeaders(headers, "x-ms-blob-content-length", fmt.Sprintf("%v", b.Properties.ContentLength))
+ if options != nil && options.SequenceNumberAction != nil {
+ headers = addToHeaders(headers, "x-ms-sequence-number-action", string(*options.SequenceNumberAction))
+ if *options.SequenceNumberAction != SequenceNumberActionIncrement {
+ headers = addToHeaders(headers, "x-ms-blob-sequence-number", fmt.Sprintf("%v", b.Properties.SequenceNumber))
+ }
+ }
+ }
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusOK})
+}
+
+// SetBlobMetadataOptions includes the options for a set blob metadata operation
+type SetBlobMetadataOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// SetMetadata replaces the metadata for the specified blob.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetBlobMetadata. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+func (b *Blob) SetMetadata(options *SetBlobMetadataOptions) error {
+ params := url.Values{"comp": {"metadata"}}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers = b.Container.bsc.client.addMetadataToHeaders(headers, b.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusOK})
+}
+
+// GetBlobMetadataOptions includes the options for a get blob metadata operation
+type GetBlobMetadataOptions struct {
+ Timeout uint
+ Snapshot *time.Time
+ LeaseID string `header:"x-ms-lease-id"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// GetMetadata returns all user-defined metadata for the specified blob.
+//
+// All metadata keys will be returned in lower case. (HTTP header
+// names are case-insensitive.)
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+func (b *Blob) GetMetadata(options *GetBlobMetadataOptions) error {
+ params := url.Values{"comp": {"metadata"}}
+ headers := b.Container.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ params = addSnapshot(params, options.Snapshot)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodGet, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return err
+ }
+
+ b.writeMetadata(resp.Header)
+ return nil
+}
+
+func (b *Blob) writeMetadata(h http.Header) {
+ b.Metadata = BlobMetadata(writeMetadata(h))
+}
+
+// DeleteBlobOptions includes the options for a delete blob operation
+type DeleteBlobOptions struct {
+ Timeout uint
+ Snapshot *time.Time
+ LeaseID string `header:"x-ms-lease-id"`
+ DeleteSnapshots *bool
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Delete deletes the given blob from the specified container.
+// If the blob does not exist at the time of the Delete Blob operation, it
+// returns error.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-Blob
+func (b *Blob) Delete(options *DeleteBlobOptions) error {
+ resp, err := b.delete(options)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusAccepted})
+}
+
+// DeleteIfExists deletes the given blob from the specified container If the
+// blob is deleted with this call, returns true. Otherwise returns false.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-Blob
+func (b *Blob) DeleteIfExists(options *DeleteBlobOptions) (bool, error) {
+ resp, err := b.delete(options)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusAccepted || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusAccepted, nil
+ }
+ }
+ return false, err
+}
+
+func (b *Blob) delete(options *DeleteBlobOptions) (*http.Response, error) {
+ params := url.Values{}
+ headers := b.Container.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ params = addSnapshot(params, options.Snapshot)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ if options.DeleteSnapshots != nil {
+ if *options.DeleteSnapshots {
+ headers["x-ms-delete-snapshots"] = "include"
+ } else {
+ headers["x-ms-delete-snapshots"] = "only"
+ }
+ }
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+ return b.Container.bsc.client.exec(http.MethodDelete, uri, headers, nil, b.Container.bsc.auth)
+}
+
+// helper method to construct the path to either a blob or container
+func pathForResource(container, name string) string {
+ if name != "" {
+ return fmt.Sprintf("/%s/%s", container, name)
+ }
+ return fmt.Sprintf("/%s", container)
+}
+
+func (b *Blob) respondCreation(resp *http.Response, bt BlobType) error {
+ defer drainRespBody(resp)
+ err := checkRespCode(resp, []int{http.StatusCreated})
+ if err != nil {
+ return err
+ }
+ b.Properties.BlobType = bt
+ return nil
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/blobsasuri.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/blobsasuri.go
new file mode 100644
index 00000000000..62e461a5592
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/blobsasuri.go
@@ -0,0 +1,179 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "errors"
+ "fmt"
+ "net/url"
+ "strings"
+ "time"
+)
+
+// OverrideHeaders defines overridable response heaedrs in
+// a request using a SAS URI.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+type OverrideHeaders struct {
+ CacheControl string
+ ContentDisposition string
+ ContentEncoding string
+ ContentLanguage string
+ ContentType string
+}
+
+// BlobSASOptions are options to construct a blob SAS
+// URI.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+type BlobSASOptions struct {
+ BlobServiceSASPermissions
+ OverrideHeaders
+ SASOptions
+}
+
+// BlobServiceSASPermissions includes the available permissions for
+// blob service SAS URI.
+type BlobServiceSASPermissions struct {
+ Read bool
+ Add bool
+ Create bool
+ Write bool
+ Delete bool
+}
+
+func (p BlobServiceSASPermissions) buildString() string {
+ permissions := ""
+ if p.Read {
+ permissions += "r"
+ }
+ if p.Add {
+ permissions += "a"
+ }
+ if p.Create {
+ permissions += "c"
+ }
+ if p.Write {
+ permissions += "w"
+ }
+ if p.Delete {
+ permissions += "d"
+ }
+ return permissions
+}
+
+// GetSASURI creates an URL to the blob which contains the Shared
+// Access Signature with the specified options.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+func (b *Blob) GetSASURI(options BlobSASOptions) (string, error) {
+ uri := b.GetURL()
+ signedResource := "b"
+ canonicalizedResource, err := b.Container.bsc.client.buildCanonicalizedResource(uri, b.Container.bsc.auth, true)
+ if err != nil {
+ return "", err
+ }
+
+ permissions := options.BlobServiceSASPermissions.buildString()
+ return b.Container.bsc.client.blobAndFileSASURI(options.SASOptions, uri, permissions, canonicalizedResource, signedResource, options.OverrideHeaders)
+}
+
+func (c *Client) blobAndFileSASURI(options SASOptions, uri, permissions, canonicalizedResource, signedResource string, headers OverrideHeaders) (string, error) {
+ start := ""
+ if options.Start != (time.Time{}) {
+ start = options.Start.UTC().Format(time.RFC3339)
+ }
+
+ expiry := options.Expiry.UTC().Format(time.RFC3339)
+
+ // We need to replace + with %2b first to avoid being treated as a space (which is correct for query strings, but not the path component).
+ canonicalizedResource = strings.Replace(canonicalizedResource, "+", "%2b", -1)
+ canonicalizedResource, err := url.QueryUnescape(canonicalizedResource)
+ if err != nil {
+ return "", err
+ }
+
+ protocols := ""
+ if options.UseHTTPS {
+ protocols = "https"
+ }
+ stringToSign, err := blobSASStringToSign(permissions, start, expiry, canonicalizedResource, options.Identifier, options.IP, protocols, c.apiVersion, signedResource, "", headers)
+ if err != nil {
+ return "", err
+ }
+
+ sig := c.computeHmac256(stringToSign)
+ sasParams := url.Values{
+ "sv": {c.apiVersion},
+ "se": {expiry},
+ "sr": {signedResource},
+ "sp": {permissions},
+ "sig": {sig},
+ }
+
+ if start != "" {
+ sasParams.Add("st", start)
+ }
+
+ if c.apiVersion >= "2015-04-05" {
+ if protocols != "" {
+ sasParams.Add("spr", protocols)
+ }
+ if options.IP != "" {
+ sasParams.Add("sip", options.IP)
+ }
+ }
+
+ // Add override response hedaers
+ addQueryParameter(sasParams, "rscc", headers.CacheControl)
+ addQueryParameter(sasParams, "rscd", headers.ContentDisposition)
+ addQueryParameter(sasParams, "rsce", headers.ContentEncoding)
+ addQueryParameter(sasParams, "rscl", headers.ContentLanguage)
+ addQueryParameter(sasParams, "rsct", headers.ContentType)
+
+ sasURL, err := url.Parse(uri)
+ if err != nil {
+ return "", err
+ }
+ sasURL.RawQuery = sasParams.Encode()
+ return sasURL.String(), nil
+}
+
+func blobSASStringToSign(signedPermissions, signedStart, signedExpiry, canonicalizedResource, signedIdentifier, signedIP, protocols, signedVersion, signedResource, signedSnapshotTime string, headers OverrideHeaders) (string, error) {
+ rscc := headers.CacheControl
+ rscd := headers.ContentDisposition
+ rsce := headers.ContentEncoding
+ rscl := headers.ContentLanguage
+ rsct := headers.ContentType
+
+ if signedVersion >= "2015-02-21" {
+ canonicalizedResource = "/blob" + canonicalizedResource
+ }
+
+ // https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+ if signedVersion >= "2018-11-09" {
+ return fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s", signedPermissions, signedStart, signedExpiry, canonicalizedResource, signedIdentifier, signedIP, protocols, signedVersion, signedResource, signedSnapshotTime, rscc, rscd, rsce, rscl, rsct), nil
+ }
+
+ // https://msdn.microsoft.com/en-us/library/azure/dn140255.aspx#Anchor_12
+ if signedVersion >= "2015-04-05" {
+ return fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s", signedPermissions, signedStart, signedExpiry, canonicalizedResource, signedIdentifier, signedIP, protocols, signedVersion, rscc, rscd, rsce, rscl, rsct), nil
+ }
+
+ // reference: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
+ if signedVersion >= "2013-08-15" {
+ return fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s", signedPermissions, signedStart, signedExpiry, canonicalizedResource, signedIdentifier, signedVersion, rscc, rscd, rsce, rscl, rsct), nil
+ }
+
+ return "", errors.New("storage: not implemented SAS for versions earlier than 2013-08-15")
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/blobserviceclient.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/blobserviceclient.go
new file mode 100644
index 00000000000..02fa5929cc1
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/blobserviceclient.go
@@ -0,0 +1,186 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+)
+
+// BlobStorageClient contains operations for Microsoft Azure Blob Storage
+// Service.
+type BlobStorageClient struct {
+ client Client
+ auth authentication
+}
+
+// GetServiceProperties gets the properties of your storage account's blob service.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-blob-service-properties
+func (b *BlobStorageClient) GetServiceProperties() (*ServiceProperties, error) {
+ return b.client.getServiceProperties(blobServiceName, b.auth)
+}
+
+// SetServiceProperties sets the properties of your storage account's blob service.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/set-blob-service-properties
+func (b *BlobStorageClient) SetServiceProperties(props ServiceProperties) error {
+ return b.client.setServiceProperties(props, blobServiceName, b.auth)
+}
+
+// ListContainersParameters defines the set of customizable parameters to make a
+// List Containers call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179352.aspx
+type ListContainersParameters struct {
+ Prefix string
+ Marker string
+ Include string
+ MaxResults uint
+ Timeout uint
+}
+
+// GetContainerReference returns a Container object for the specified container name.
+func (b *BlobStorageClient) GetContainerReference(name string) *Container {
+ return &Container{
+ bsc: b,
+ Name: name,
+ }
+}
+
+// GetContainerReferenceFromSASURI returns a Container object for the specified
+// container SASURI
+func GetContainerReferenceFromSASURI(sasuri url.URL) (*Container, error) {
+ path := strings.Split(sasuri.Path, "/")
+ if len(path) <= 1 {
+ return nil, fmt.Errorf("could not find a container in URI: %s", sasuri.String())
+ }
+ c, err := newSASClientFromURL(&sasuri)
+ if err != nil {
+ return nil, err
+ }
+ cli := c.GetBlobService()
+ return &Container{
+ bsc: &cli,
+ Name: path[1],
+ sasuri: sasuri,
+ }, nil
+}
+
+// ListContainers returns the list of containers in a storage account along with
+// pagination token and other response details.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179352.aspx
+func (b BlobStorageClient) ListContainers(params ListContainersParameters) (*ContainerListResponse, error) {
+ q := mergeParams(params.getParameters(), url.Values{"comp": {"list"}})
+ uri := b.client.getEndpoint(blobServiceName, "", q)
+ headers := b.client.getStandardHeaders()
+
+ type ContainerAlias struct {
+ bsc *BlobStorageClient
+ Name string `xml:"Name"`
+ Properties ContainerProperties `xml:"Properties"`
+ Metadata BlobMetadata
+ sasuri url.URL
+ }
+ type ContainerListResponseAlias struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Prefix string `xml:"Prefix"`
+ Marker string `xml:"Marker"`
+ NextMarker string `xml:"NextMarker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Containers []ContainerAlias `xml:"Containers>Container"`
+ }
+
+ var outAlias ContainerListResponseAlias
+ resp, err := b.client.exec(http.MethodGet, uri, headers, nil, b.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+ err = xmlUnmarshal(resp.Body, &outAlias)
+ if err != nil {
+ return nil, err
+ }
+
+ out := ContainerListResponse{
+ XMLName: outAlias.XMLName,
+ Xmlns: outAlias.Xmlns,
+ Prefix: outAlias.Prefix,
+ Marker: outAlias.Marker,
+ NextMarker: outAlias.NextMarker,
+ MaxResults: outAlias.MaxResults,
+ Containers: make([]Container, len(outAlias.Containers)),
+ }
+ for i, cnt := range outAlias.Containers {
+ out.Containers[i] = Container{
+ bsc: &b,
+ Name: cnt.Name,
+ Properties: cnt.Properties,
+ Metadata: map[string]string(cnt.Metadata),
+ sasuri: cnt.sasuri,
+ }
+ }
+
+ return &out, err
+}
+
+func (p ListContainersParameters) getParameters() url.Values {
+ out := url.Values{}
+
+ if p.Prefix != "" {
+ out.Set("prefix", p.Prefix)
+ }
+ if p.Marker != "" {
+ out.Set("marker", p.Marker)
+ }
+ if p.Include != "" {
+ out.Set("include", p.Include)
+ }
+ if p.MaxResults != 0 {
+ out.Set("maxresults", strconv.FormatUint(uint64(p.MaxResults), 10))
+ }
+ if p.Timeout != 0 {
+ out.Set("timeout", strconv.FormatUint(uint64(p.Timeout), 10))
+ }
+
+ return out
+}
+
+func writeMetadata(h http.Header) map[string]string {
+ metadata := make(map[string]string)
+ for k, v := range h {
+ // Can't trust CanonicalHeaderKey() to munge case
+ // reliably. "_" is allowed in identifiers:
+ // https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+ // https://msdn.microsoft.com/library/aa664670(VS.71).aspx
+ // http://tools.ietf.org/html/rfc7230#section-3.2
+ // ...but "_" is considered invalid by
+ // CanonicalMIMEHeaderKey in
+ // https://golang.org/src/net/textproto/reader.go?s=14615:14659#L542
+ // so k can be "X-Ms-Meta-Lol" or "x-ms-meta-lol_rofl".
+ k = strings.ToLower(k)
+ if len(v) == 0 || !strings.HasPrefix(k, strings.ToLower(userDefinedMetadataHeaderPrefix)) {
+ continue
+ }
+ // metadata["lol"] = content of the last X-Ms-Meta-Lol header
+ k = k[len(userDefinedMetadataHeaderPrefix):]
+ metadata[k] = v[len(v)-1]
+ }
+ return metadata
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/blockblob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/blockblob.go
new file mode 100644
index 00000000000..bd19eccc41e
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/blockblob.go
@@ -0,0 +1,311 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bytes"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// BlockListType is used to filter out types of blocks in a Get Blocks List call
+// for a block blob.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179400.aspx for all
+// block types.
+type BlockListType string
+
+// Filters for listing blocks in block blobs
+const (
+ BlockListTypeAll BlockListType = "all"
+ BlockListTypeCommitted BlockListType = "committed"
+ BlockListTypeUncommitted BlockListType = "uncommitted"
+)
+
+// Maximum sizes (per REST API) for various concepts
+const (
+ MaxBlobBlockSize = 100 * 1024 * 1024
+ MaxBlobPageSize = 4 * 1024 * 1024
+)
+
+// BlockStatus defines states a block for a block blob can
+// be in.
+type BlockStatus string
+
+// List of statuses that can be used to refer to a block in a block list
+const (
+ BlockStatusUncommitted BlockStatus = "Uncommitted"
+ BlockStatusCommitted BlockStatus = "Committed"
+ BlockStatusLatest BlockStatus = "Latest"
+)
+
+// Block is used to create Block entities for Put Block List
+// call.
+type Block struct {
+ ID string
+ Status BlockStatus
+}
+
+// BlockListResponse contains the response fields from Get Block List call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179400.aspx
+type BlockListResponse struct {
+ XMLName xml.Name `xml:"BlockList"`
+ CommittedBlocks []BlockResponse `xml:"CommittedBlocks>Block"`
+ UncommittedBlocks []BlockResponse `xml:"UncommittedBlocks>Block"`
+}
+
+// BlockResponse contains the block information returned
+// in the GetBlockListCall.
+type BlockResponse struct {
+ Name string `xml:"Name"`
+ Size int64 `xml:"Size"`
+}
+
+// CreateBlockBlob initializes an empty block blob with no blocks.
+//
+// See CreateBlockBlobFromReader for more info on creating blobs.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Blob
+func (b *Blob) CreateBlockBlob(options *PutBlobOptions) error {
+ return b.CreateBlockBlobFromReader(nil, options)
+}
+
+// CreateBlockBlobFromReader initializes a block blob using data from
+// reader. Size must be the number of bytes read from reader. To
+// create an empty blob, use size==0 and reader==nil.
+//
+// Any headers set in blob.Properties or metadata in blob.Metadata
+// will be set on the blob.
+//
+// The API rejects requests with size > 256 MiB (but this limit is not
+// checked by the SDK). To write a larger blob, use CreateBlockBlob,
+// PutBlock, and PutBlockList.
+//
+// To create a blob from scratch, call container.GetBlobReference() to
+// get an empty blob, fill in blob.Properties and blob.Metadata as
+// appropriate then call this method.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Blob
+func (b *Blob) CreateBlockBlobFromReader(blob io.Reader, options *PutBlobOptions) error {
+ params := url.Values{}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypeBlock)
+
+ headers["Content-Length"] = "0"
+ var n int64
+ var err error
+ if blob != nil {
+ type lener interface {
+ Len() int
+ }
+ // TODO(rjeczalik): handle io.ReadSeeker, in case blob is *os.File etc.
+ if l, ok := blob.(lener); ok {
+ n = int64(l.Len())
+ } else {
+ var buf bytes.Buffer
+ n, err = io.Copy(&buf, blob)
+ if err != nil {
+ return err
+ }
+ blob = &buf
+ }
+
+ headers["Content-Length"] = strconv.FormatInt(n, 10)
+ }
+ b.Properties.ContentLength = n
+
+ headers = mergeHeaders(headers, headersFromStruct(b.Properties))
+ headers = b.Container.bsc.client.addMetadataToHeaders(headers, b.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, blob, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ return b.respondCreation(resp, BlobTypeBlock)
+}
+
+// PutBlockOptions includes the options for a put block operation
+type PutBlockOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ ContentMD5 string `header:"Content-MD5"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// PutBlock saves the given data chunk to the specified block blob with
+// given ID.
+//
+// The API rejects chunks larger than 100 MiB (but this limit is not
+// checked by the SDK).
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Block
+func (b *Blob) PutBlock(blockID string, chunk []byte, options *PutBlockOptions) error {
+ return b.PutBlockWithLength(blockID, uint64(len(chunk)), bytes.NewReader(chunk), options)
+}
+
+// PutBlockWithLength saves the given data stream of exactly specified size to
+// the block blob with given ID. It is an alternative to PutBlocks where data
+// comes as stream but the length is known in advance.
+//
+// The API rejects requests with size > 100 MiB (but this limit is not
+// checked by the SDK).
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Block
+func (b *Blob) PutBlockWithLength(blockID string, size uint64, blob io.Reader, options *PutBlockOptions) error {
+ query := url.Values{
+ "comp": {"block"},
+ "blockid": {blockID},
+ }
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["Content-Length"] = fmt.Sprintf("%v", size)
+
+ if options != nil {
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), query)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, blob, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ return b.respondCreation(resp, BlobTypeBlock)
+}
+
+// PutBlockFromURLOptions includes the options for a put block from URL operation
+type PutBlockFromURLOptions struct {
+ PutBlockOptions
+
+ SourceContentMD5 string `header:"x-ms-source-content-md5"`
+ SourceContentCRC64 string `header:"x-ms-source-content-crc64"`
+}
+
+// PutBlockFromURL copy data of exactly specified size from specified URL to
+// the block blob with given ID. It is an alternative to PutBlocks where data
+// comes from a remote URL and the offset and length is known in advance.
+//
+// The API rejects requests with size > 100 MiB (but this limit is not
+// checked by the SDK).
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/put-block-from-url
+func (b *Blob) PutBlockFromURL(blockID string, blobURL string, offset int64, size uint64, options *PutBlockFromURLOptions) error {
+ query := url.Values{
+ "comp": {"block"},
+ "blockid": {blockID},
+ }
+ headers := b.Container.bsc.client.getStandardHeaders()
+ // The value of this header must be set to zero.
+ // When the length is not zero, the operation will fail with the status code 400 (Bad Request).
+ headers["Content-Length"] = "0"
+ headers["x-ms-copy-source"] = blobURL
+ headers["x-ms-source-range"] = fmt.Sprintf("bytes=%d-%d", offset, uint64(offset)+size-1)
+
+ if options != nil {
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), query)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ return b.respondCreation(resp, BlobTypeBlock)
+}
+
+// PutBlockListOptions includes the options for a put block list operation
+type PutBlockListOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// PutBlockList saves list of blocks to the specified block blob.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Block-List
+func (b *Blob) PutBlockList(blocks []Block, options *PutBlockListOptions) error {
+ params := url.Values{"comp": {"blocklist"}}
+ blockListXML := prepareBlockListRequest(blocks)
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["Content-Length"] = fmt.Sprintf("%v", len(blockListXML))
+ headers = mergeHeaders(headers, headersFromStruct(b.Properties))
+ headers = b.Container.bsc.client.addMetadataToHeaders(headers, b.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, strings.NewReader(blockListXML), b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusCreated})
+}
+
+// GetBlockListOptions includes the options for a get block list operation
+type GetBlockListOptions struct {
+ Timeout uint
+ Snapshot *time.Time
+ LeaseID string `header:"x-ms-lease-id"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// GetBlockList retrieves list of blocks in the specified block blob.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Get-Block-List
+func (b *Blob) GetBlockList(blockType BlockListType, options *GetBlockListOptions) (BlockListResponse, error) {
+ params := url.Values{
+ "comp": {"blocklist"},
+ "blocklisttype": {string(blockType)},
+ }
+ headers := b.Container.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ params = addSnapshot(params, options.Snapshot)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ var out BlockListResponse
+ resp, err := b.Container.bsc.client.exec(http.MethodGet, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return out, err
+ }
+ defer resp.Body.Close()
+
+ err = xmlUnmarshal(resp.Body, &out)
+ return out, err
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/client.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/client.go
new file mode 100644
index 00000000000..ef8daf92e27
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/client.go
@@ -0,0 +1,1040 @@
+// Package storage provides clients for Microsoft Azure Storage Services.
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bufio"
+ "encoding/base64"
+ "encoding/json"
+ "encoding/xml"
+ "errors"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "mime"
+ "mime/multipart"
+ "net/http"
+ "net/url"
+ "regexp"
+ "runtime"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/Azure/azure-sdk-for-go/version"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+)
+
+const (
+ // DefaultBaseURL is the domain name used for storage requests in the
+ // public cloud when a default client is created.
+ DefaultBaseURL = "core.windows.net"
+
+ // DefaultAPIVersion is the Azure Storage API version string used when a
+ // basic client is created.
+ DefaultAPIVersion = "2018-03-28"
+
+ defaultUseHTTPS = true
+ defaultRetryAttempts = 5
+ defaultRetryDuration = time.Second * 5
+
+ // StorageEmulatorAccountName is the fixed storage account used by Azure Storage Emulator
+ StorageEmulatorAccountName = "devstoreaccount1"
+
+ // StorageEmulatorAccountKey is the the fixed storage account used by Azure Storage Emulator
+ StorageEmulatorAccountKey = "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw=="
+
+ blobServiceName = "blob"
+ tableServiceName = "table"
+ queueServiceName = "queue"
+ fileServiceName = "file"
+
+ storageEmulatorBlob = "127.0.0.1:10000"
+ storageEmulatorTable = "127.0.0.1:10002"
+ storageEmulatorQueue = "127.0.0.1:10001"
+
+ userAgentHeader = "User-Agent"
+
+ userDefinedMetadataHeaderPrefix = "x-ms-meta-"
+
+ connectionStringAccountName = "accountname"
+ connectionStringAccountKey = "accountkey"
+ connectionStringEndpointSuffix = "endpointsuffix"
+ connectionStringEndpointProtocol = "defaultendpointsprotocol"
+
+ connectionStringBlobEndpoint = "blobendpoint"
+ connectionStringFileEndpoint = "fileendpoint"
+ connectionStringQueueEndpoint = "queueendpoint"
+ connectionStringTableEndpoint = "tableendpoint"
+ connectionStringSAS = "sharedaccesssignature"
+)
+
+var (
+ validStorageAccount = regexp.MustCompile("^[0-9a-z]{3,24}$")
+ validCosmosAccount = regexp.MustCompile("^[0-9a-z-]{3,44}$")
+ defaultValidStatusCodes = []int{
+ http.StatusRequestTimeout, // 408
+ http.StatusInternalServerError, // 500
+ http.StatusBadGateway, // 502
+ http.StatusServiceUnavailable, // 503
+ http.StatusGatewayTimeout, // 504
+ }
+)
+
+// Sender sends a request
+type Sender interface {
+ Send(*Client, *http.Request) (*http.Response, error)
+}
+
+// DefaultSender is the default sender for the client. It implements
+// an automatic retry strategy.
+type DefaultSender struct {
+ RetryAttempts int
+ RetryDuration time.Duration
+ ValidStatusCodes []int
+ attempts int // used for testing
+}
+
+// Send is the default retry strategy in the client
+func (ds *DefaultSender) Send(c *Client, req *http.Request) (resp *http.Response, err error) {
+ rr := autorest.NewRetriableRequest(req)
+ for attempts := 0; attempts < ds.RetryAttempts; attempts++ {
+ err = rr.Prepare()
+ if err != nil {
+ return resp, err
+ }
+ resp, err = c.HTTPClient.Do(rr.Request())
+ if err != nil || !autorest.ResponseHasStatusCode(resp, ds.ValidStatusCodes...) {
+ return resp, err
+ }
+ drainRespBody(resp)
+ autorest.DelayForBackoff(ds.RetryDuration, attempts, req.Cancel)
+ ds.attempts = attempts
+ }
+ ds.attempts++
+ return resp, err
+}
+
+// Client is the object that needs to be constructed to perform
+// operations on the storage account.
+type Client struct {
+ // HTTPClient is the http.Client used to initiate API
+ // requests. http.DefaultClient is used when creating a
+ // client.
+ HTTPClient *http.Client
+
+ // Sender is an interface that sends the request. Clients are
+ // created with a DefaultSender. The DefaultSender has an
+ // automatic retry strategy built in. The Sender can be customized.
+ Sender Sender
+
+ accountName string
+ accountKey []byte
+ useHTTPS bool
+ UseSharedKeyLite bool
+ baseURL string
+ apiVersion string
+ userAgent string
+ sasClient bool
+ accountSASToken url.Values
+ additionalHeaders map[string]string
+}
+
+type odataResponse struct {
+ resp *http.Response
+ odata odataErrorWrapper
+}
+
+// AzureStorageServiceError contains fields of the error response from
+// Azure Storage Service REST API. See https://msdn.microsoft.com/en-us/library/azure/dd179382.aspx
+// Some fields might be specific to certain calls.
+type AzureStorageServiceError struct {
+ Code string `xml:"Code"`
+ Message string `xml:"Message"`
+ AuthenticationErrorDetail string `xml:"AuthenticationErrorDetail"`
+ QueryParameterName string `xml:"QueryParameterName"`
+ QueryParameterValue string `xml:"QueryParameterValue"`
+ Reason string `xml:"Reason"`
+ Lang string
+ StatusCode int
+ RequestID string
+ Date string
+ APIVersion string
+}
+
+type odataErrorMessage struct {
+ Lang string `json:"lang"`
+ Value string `json:"value"`
+}
+
+type odataError struct {
+ Code string `json:"code"`
+ Message odataErrorMessage `json:"message"`
+}
+
+type odataErrorWrapper struct {
+ Err odataError `json:"odata.error"`
+}
+
+// UnexpectedStatusCodeError is returned when a storage service responds with neither an error
+// nor with an HTTP status code indicating success.
+type UnexpectedStatusCodeError struct {
+ allowed []int
+ got int
+ inner error
+}
+
+func (e UnexpectedStatusCodeError) Error() string {
+ s := func(i int) string { return fmt.Sprintf("%d %s", i, http.StatusText(i)) }
+
+ got := s(e.got)
+ expected := []string{}
+ for _, v := range e.allowed {
+ expected = append(expected, s(v))
+ }
+ return fmt.Sprintf("storage: status code from service response is %s; was expecting %s. Inner error: %+v", got, strings.Join(expected, " or "), e.inner)
+}
+
+// Got is the actual status code returned by Azure.
+func (e UnexpectedStatusCodeError) Got() int {
+ return e.got
+}
+
+// Inner returns any inner error info.
+func (e UnexpectedStatusCodeError) Inner() error {
+ return e.inner
+}
+
+// NewClientFromConnectionString creates a Client from the connection string.
+func NewClientFromConnectionString(input string) (Client, error) {
+ // build a map of connection string key/value pairs
+ parts := map[string]string{}
+ for _, pair := range strings.Split(input, ";") {
+ if pair == "" {
+ continue
+ }
+
+ equalDex := strings.IndexByte(pair, '=')
+ if equalDex <= 0 {
+ return Client{}, fmt.Errorf("Invalid connection segment %q", pair)
+ }
+
+ value := strings.TrimSpace(pair[equalDex+1:])
+ key := strings.TrimSpace(strings.ToLower(pair[:equalDex]))
+ parts[key] = value
+ }
+
+ // TODO: validate parameter sets?
+
+ if parts[connectionStringAccountName] == StorageEmulatorAccountName {
+ return NewEmulatorClient()
+ }
+
+ if parts[connectionStringSAS] != "" {
+ endpoint := ""
+ if parts[connectionStringBlobEndpoint] != "" {
+ endpoint = parts[connectionStringBlobEndpoint]
+ } else if parts[connectionStringFileEndpoint] != "" {
+ endpoint = parts[connectionStringFileEndpoint]
+ } else if parts[connectionStringQueueEndpoint] != "" {
+ endpoint = parts[connectionStringQueueEndpoint]
+ } else {
+ endpoint = parts[connectionStringTableEndpoint]
+ }
+
+ return NewAccountSASClientFromEndpointToken(endpoint, parts[connectionStringSAS])
+ }
+
+ useHTTPS := defaultUseHTTPS
+ if parts[connectionStringEndpointProtocol] != "" {
+ useHTTPS = parts[connectionStringEndpointProtocol] == "https"
+ }
+
+ return NewClient(parts[connectionStringAccountName], parts[connectionStringAccountKey],
+ parts[connectionStringEndpointSuffix], DefaultAPIVersion, useHTTPS)
+}
+
+// NewBasicClient constructs a Client with given storage service name and
+// key.
+func NewBasicClient(accountName, accountKey string) (Client, error) {
+ if accountName == StorageEmulatorAccountName {
+ return NewEmulatorClient()
+ }
+ return NewClient(accountName, accountKey, DefaultBaseURL, DefaultAPIVersion, defaultUseHTTPS)
+}
+
+// NewBasicClientOnSovereignCloud constructs a Client with given storage service name and
+// key in the referenced cloud.
+func NewBasicClientOnSovereignCloud(accountName, accountKey string, env azure.Environment) (Client, error) {
+ if accountName == StorageEmulatorAccountName {
+ return NewEmulatorClient()
+ }
+ return NewClient(accountName, accountKey, env.StorageEndpointSuffix, DefaultAPIVersion, defaultUseHTTPS)
+}
+
+//NewEmulatorClient contructs a Client intended to only work with Azure
+//Storage Emulator
+func NewEmulatorClient() (Client, error) {
+ return NewClient(StorageEmulatorAccountName, StorageEmulatorAccountKey, DefaultBaseURL, DefaultAPIVersion, false)
+}
+
+// NewClient constructs a Client. This should be used if the caller wants
+// to specify whether to use HTTPS, a specific REST API version or a custom
+// storage endpoint than Azure Public Cloud.
+func NewClient(accountName, accountKey, serviceBaseURL, apiVersion string, useHTTPS bool) (Client, error) {
+ var c Client
+ if !IsValidStorageAccount(accountName) {
+ return c, fmt.Errorf("azure: account name is not valid: it must be between 3 and 24 characters, and only may contain numbers and lowercase letters: %v", accountName)
+ } else if accountKey == "" {
+ return c, fmt.Errorf("azure: account key required")
+ } else if serviceBaseURL == "" {
+ return c, fmt.Errorf("azure: base storage service url required")
+ }
+
+ key, err := base64.StdEncoding.DecodeString(accountKey)
+ if err != nil {
+ return c, fmt.Errorf("azure: malformed storage account key: %v", err)
+ }
+
+ return newClient(accountName, key, serviceBaseURL, apiVersion, useHTTPS)
+}
+
+// NewCosmosClient constructs a Client for Azure CosmosDB. This should be used if the caller wants
+// to specify whether to use HTTPS, a specific REST API version or a custom
+// cosmos endpoint than Azure Public Cloud.
+func NewCosmosClient(accountName, accountKey, serviceBaseURL, apiVersion string, useHTTPS bool) (Client, error) {
+ var c Client
+ if !IsValidCosmosAccount(accountName) {
+ return c, fmt.Errorf("azure: account name is not valid: The name can contain only lowercase letters, numbers and the '-' character, and must be between 3 and 44 characters: %v", accountName)
+ } else if accountKey == "" {
+ return c, fmt.Errorf("azure: account key required")
+ } else if serviceBaseURL == "" {
+ return c, fmt.Errorf("azure: base storage service url required")
+ }
+
+ key, err := base64.StdEncoding.DecodeString(accountKey)
+ if err != nil {
+ return c, fmt.Errorf("azure: malformed cosmos account key: %v", err)
+ }
+
+ return newClient(accountName, key, serviceBaseURL, apiVersion, useHTTPS)
+}
+
+// newClient constructs a Client with given parameters.
+func newClient(accountName string, accountKey []byte, serviceBaseURL, apiVersion string, useHTTPS bool) (Client, error) {
+ c := Client{
+ HTTPClient: http.DefaultClient,
+ accountName: accountName,
+ accountKey: accountKey,
+ useHTTPS: useHTTPS,
+ baseURL: serviceBaseURL,
+ apiVersion: apiVersion,
+ sasClient: false,
+ UseSharedKeyLite: false,
+ Sender: &DefaultSender{
+ RetryAttempts: defaultRetryAttempts,
+ ValidStatusCodes: defaultValidStatusCodes,
+ RetryDuration: defaultRetryDuration,
+ },
+ }
+ c.userAgent = c.getDefaultUserAgent()
+ return c, nil
+}
+
+// IsValidStorageAccount checks if the storage account name is valid.
+// See https://docs.microsoft.com/en-us/azure/storage/storage-create-storage-account
+func IsValidStorageAccount(account string) bool {
+ return validStorageAccount.MatchString(account)
+}
+
+// IsValidCosmosAccount checks if the Cosmos account name is valid.
+// See https://docs.microsoft.com/en-us/azure/cosmos-db/how-to-manage-database-account
+func IsValidCosmosAccount(account string) bool {
+ return validCosmosAccount.MatchString(account)
+}
+
+// NewAccountSASClient contructs a client that uses accountSAS authorization
+// for its operations.
+func NewAccountSASClient(account string, token url.Values, env azure.Environment) Client {
+ return newSASClient(account, env.StorageEndpointSuffix, token)
+}
+
+// NewAccountSASClientFromEndpointToken constructs a client that uses accountSAS authorization
+// for its operations using the specified endpoint and SAS token.
+func NewAccountSASClientFromEndpointToken(endpoint string, sasToken string) (Client, error) {
+ u, err := url.Parse(endpoint)
+ if err != nil {
+ return Client{}, err
+ }
+ _, err = url.ParseQuery(sasToken)
+ if err != nil {
+ return Client{}, err
+ }
+ u.RawQuery = sasToken
+ return newSASClientFromURL(u)
+}
+
+func newSASClient(accountName, baseURL string, sasToken url.Values) Client {
+ c := Client{
+ HTTPClient: http.DefaultClient,
+ apiVersion: DefaultAPIVersion,
+ sasClient: true,
+ Sender: &DefaultSender{
+ RetryAttempts: defaultRetryAttempts,
+ ValidStatusCodes: defaultValidStatusCodes,
+ RetryDuration: defaultRetryDuration,
+ },
+ accountName: accountName,
+ baseURL: baseURL,
+ accountSASToken: sasToken,
+ useHTTPS: defaultUseHTTPS,
+ }
+ c.userAgent = c.getDefaultUserAgent()
+ // Get API version and protocol from token
+ c.apiVersion = sasToken.Get("sv")
+ if spr := sasToken.Get("spr"); spr != "" {
+ c.useHTTPS = spr == "https"
+ }
+ return c
+}
+
+func newSASClientFromURL(u *url.URL) (Client, error) {
+ // the host name will look something like this
+ // - foo.blob.core.windows.net
+ // "foo" is the account name
+ // "core.windows.net" is the baseURL
+
+ // find the first dot to get account name
+ i1 := strings.IndexByte(u.Host, '.')
+ if i1 < 0 {
+ return Client{}, fmt.Errorf("failed to find '.' in %s", u.Host)
+ }
+
+ // now find the second dot to get the base URL
+ i2 := strings.IndexByte(u.Host[i1+1:], '.')
+ if i2 < 0 {
+ return Client{}, fmt.Errorf("failed to find '.' in %s", u.Host[i1+1:])
+ }
+
+ sasToken := u.Query()
+ c := newSASClient(u.Host[:i1], u.Host[i1+i2+2:], sasToken)
+ if spr := sasToken.Get("spr"); spr == "" {
+ // infer from URL if not in the query params set
+ c.useHTTPS = u.Scheme == "https"
+ }
+ return c, nil
+}
+
+func (c Client) isServiceSASClient() bool {
+ return c.sasClient && c.accountSASToken == nil
+}
+
+func (c Client) isAccountSASClient() bool {
+ return c.sasClient && c.accountSASToken != nil
+}
+
+func (c Client) getDefaultUserAgent() string {
+ return fmt.Sprintf("Go/%s (%s-%s) azure-storage-go/%s api-version/%s",
+ runtime.Version(),
+ runtime.GOARCH,
+ runtime.GOOS,
+ version.Number,
+ c.apiVersion,
+ )
+}
+
+// AddToUserAgent adds an extension to the current user agent
+func (c *Client) AddToUserAgent(extension string) error {
+ if extension != "" {
+ c.userAgent = fmt.Sprintf("%s %s", c.userAgent, extension)
+ return nil
+ }
+ return fmt.Errorf("Extension was empty, User Agent stayed as %s", c.userAgent)
+}
+
+// AddAdditionalHeaders adds additional standard headers
+func (c *Client) AddAdditionalHeaders(headers map[string]string) {
+ if headers != nil {
+ c.additionalHeaders = map[string]string{}
+ for k, v := range headers {
+ c.additionalHeaders[k] = v
+ }
+ }
+}
+
+// protectUserAgent is used in funcs that include extraheaders as a parameter.
+// It prevents the User-Agent header to be overwritten, instead if it happens to
+// be present, it gets added to the current User-Agent. Use it before getStandardHeaders
+func (c *Client) protectUserAgent(extraheaders map[string]string) map[string]string {
+ if v, ok := extraheaders[userAgentHeader]; ok {
+ c.AddToUserAgent(v)
+ delete(extraheaders, userAgentHeader)
+ }
+ return extraheaders
+}
+
+func (c Client) getBaseURL(service string) *url.URL {
+ scheme := "http"
+ if c.useHTTPS {
+ scheme = "https"
+ }
+ host := ""
+ if c.accountName == StorageEmulatorAccountName {
+ switch service {
+ case blobServiceName:
+ host = storageEmulatorBlob
+ case tableServiceName:
+ host = storageEmulatorTable
+ case queueServiceName:
+ host = storageEmulatorQueue
+ }
+ } else {
+ host = fmt.Sprintf("%s.%s.%s", c.accountName, service, c.baseURL)
+ }
+
+ return &url.URL{
+ Scheme: scheme,
+ Host: host,
+ }
+}
+
+func (c Client) getEndpoint(service, path string, params url.Values) string {
+ u := c.getBaseURL(service)
+
+ // API doesn't accept path segments not starting with '/'
+ if !strings.HasPrefix(path, "/") {
+ path = fmt.Sprintf("/%v", path)
+ }
+
+ if c.accountName == StorageEmulatorAccountName {
+ path = fmt.Sprintf("/%v%v", StorageEmulatorAccountName, path)
+ }
+
+ u.Path = path
+ u.RawQuery = params.Encode()
+ return u.String()
+}
+
+// AccountSASTokenOptions includes options for constructing
+// an account SAS token.
+// https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-an-account-sas
+type AccountSASTokenOptions struct {
+ APIVersion string
+ Services Services
+ ResourceTypes ResourceTypes
+ Permissions Permissions
+ Start time.Time
+ Expiry time.Time
+ IP string
+ UseHTTPS bool
+}
+
+// Services specify services accessible with an account SAS.
+type Services struct {
+ Blob bool
+ Queue bool
+ Table bool
+ File bool
+}
+
+// ResourceTypes specify the resources accesible with an
+// account SAS.
+type ResourceTypes struct {
+ Service bool
+ Container bool
+ Object bool
+}
+
+// Permissions specifies permissions for an accountSAS.
+type Permissions struct {
+ Read bool
+ Write bool
+ Delete bool
+ List bool
+ Add bool
+ Create bool
+ Update bool
+ Process bool
+}
+
+// GetAccountSASToken creates an account SAS token
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-an-account-sas
+func (c Client) GetAccountSASToken(options AccountSASTokenOptions) (url.Values, error) {
+ if options.APIVersion == "" {
+ options.APIVersion = c.apiVersion
+ }
+
+ if options.APIVersion < "2015-04-05" {
+ return url.Values{}, fmt.Errorf("account SAS does not support API versions prior to 2015-04-05. API version : %s", options.APIVersion)
+ }
+
+ // build services string
+ services := ""
+ if options.Services.Blob {
+ services += "b"
+ }
+ if options.Services.Queue {
+ services += "q"
+ }
+ if options.Services.Table {
+ services += "t"
+ }
+ if options.Services.File {
+ services += "f"
+ }
+
+ // build resources string
+ resources := ""
+ if options.ResourceTypes.Service {
+ resources += "s"
+ }
+ if options.ResourceTypes.Container {
+ resources += "c"
+ }
+ if options.ResourceTypes.Object {
+ resources += "o"
+ }
+
+ // build permissions string
+ permissions := ""
+ if options.Permissions.Read {
+ permissions += "r"
+ }
+ if options.Permissions.Write {
+ permissions += "w"
+ }
+ if options.Permissions.Delete {
+ permissions += "d"
+ }
+ if options.Permissions.List {
+ permissions += "l"
+ }
+ if options.Permissions.Add {
+ permissions += "a"
+ }
+ if options.Permissions.Create {
+ permissions += "c"
+ }
+ if options.Permissions.Update {
+ permissions += "u"
+ }
+ if options.Permissions.Process {
+ permissions += "p"
+ }
+
+ // build start time, if exists
+ start := ""
+ if options.Start != (time.Time{}) {
+ start = options.Start.UTC().Format(time.RFC3339)
+ }
+
+ // build expiry time
+ expiry := options.Expiry.UTC().Format(time.RFC3339)
+
+ protocol := "https,http"
+ if options.UseHTTPS {
+ protocol = "https"
+ }
+
+ stringToSign := strings.Join([]string{
+ c.accountName,
+ permissions,
+ services,
+ resources,
+ start,
+ expiry,
+ options.IP,
+ protocol,
+ options.APIVersion,
+ "",
+ }, "\n")
+ signature := c.computeHmac256(stringToSign)
+
+ sasParams := url.Values{
+ "sv": {options.APIVersion},
+ "ss": {services},
+ "srt": {resources},
+ "sp": {permissions},
+ "se": {expiry},
+ "spr": {protocol},
+ "sig": {signature},
+ }
+ if start != "" {
+ sasParams.Add("st", start)
+ }
+ if options.IP != "" {
+ sasParams.Add("sip", options.IP)
+ }
+
+ return sasParams, nil
+}
+
+// GetBlobService returns a BlobStorageClient which can operate on the blob
+// service of the storage account.
+func (c Client) GetBlobService() BlobStorageClient {
+ b := BlobStorageClient{
+ client: c,
+ }
+ b.client.AddToUserAgent(blobServiceName)
+ b.auth = sharedKey
+ if c.UseSharedKeyLite {
+ b.auth = sharedKeyLite
+ }
+ return b
+}
+
+// GetQueueService returns a QueueServiceClient which can operate on the queue
+// service of the storage account.
+func (c Client) GetQueueService() QueueServiceClient {
+ q := QueueServiceClient{
+ client: c,
+ }
+ q.client.AddToUserAgent(queueServiceName)
+ q.auth = sharedKey
+ if c.UseSharedKeyLite {
+ q.auth = sharedKeyLite
+ }
+ return q
+}
+
+// GetTableService returns a TableServiceClient which can operate on the table
+// service of the storage account.
+func (c Client) GetTableService() TableServiceClient {
+ t := TableServiceClient{
+ client: c,
+ }
+ t.client.AddToUserAgent(tableServiceName)
+ t.auth = sharedKeyForTable
+ if c.UseSharedKeyLite {
+ t.auth = sharedKeyLiteForTable
+ }
+ return t
+}
+
+// GetFileService returns a FileServiceClient which can operate on the file
+// service of the storage account.
+func (c Client) GetFileService() FileServiceClient {
+ f := FileServiceClient{
+ client: c,
+ }
+ f.client.AddToUserAgent(fileServiceName)
+ f.auth = sharedKey
+ if c.UseSharedKeyLite {
+ f.auth = sharedKeyLite
+ }
+ return f
+}
+
+func (c Client) getStandardHeaders() map[string]string {
+ headers := map[string]string{}
+ for k, v := range c.additionalHeaders {
+ headers[k] = v
+ }
+
+ headers[userAgentHeader] = c.userAgent
+ headers["x-ms-version"] = c.apiVersion
+ headers["x-ms-date"] = currentTimeRfc1123Formatted()
+
+ return headers
+}
+
+func (c Client) exec(verb, url string, headers map[string]string, body io.Reader, auth authentication) (*http.Response, error) {
+ headers, err := c.addAuthorizationHeader(verb, url, headers, auth)
+ if err != nil {
+ return nil, err
+ }
+
+ req, err := http.NewRequest(verb, url, body)
+ if err != nil {
+ return nil, errors.New("azure/storage: error creating request: " + err.Error())
+ }
+
+ // http.NewRequest() will automatically set req.ContentLength for a handful of types
+ // otherwise we will handle here.
+ if req.ContentLength < 1 {
+ if clstr, ok := headers["Content-Length"]; ok {
+ if cl, err := strconv.ParseInt(clstr, 10, 64); err == nil {
+ req.ContentLength = cl
+ }
+ }
+ }
+
+ for k, v := range headers {
+ req.Header[k] = append(req.Header[k], v) // Must bypass case munging present in `Add` by using map functions directly. See https://github.com/Azure/azure-sdk-for-go/issues/645
+ }
+
+ if c.isAccountSASClient() {
+ // append the SAS token to the query params
+ v := req.URL.Query()
+ v = mergeParams(v, c.accountSASToken)
+ req.URL.RawQuery = v.Encode()
+ }
+
+ resp, err := c.Sender.Send(&c, req)
+ if err != nil {
+ return nil, err
+ }
+
+ if resp.StatusCode >= 400 && resp.StatusCode <= 505 {
+ return resp, getErrorFromResponse(resp)
+ }
+
+ return resp, nil
+}
+
+func (c Client) execInternalJSONCommon(verb, url string, headers map[string]string, body io.Reader, auth authentication) (*odataResponse, *http.Request, *http.Response, error) {
+ headers, err := c.addAuthorizationHeader(verb, url, headers, auth)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+
+ req, err := http.NewRequest(verb, url, body)
+ for k, v := range headers {
+ req.Header.Add(k, v)
+ }
+
+ resp, err := c.Sender.Send(&c, req)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+
+ respToRet := &odataResponse{resp: resp}
+
+ statusCode := resp.StatusCode
+ if statusCode >= 400 && statusCode <= 505 {
+ var respBody []byte
+ respBody, err = readAndCloseBody(resp.Body)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+
+ requestID, date, version := getDebugHeaders(resp.Header)
+ if len(respBody) == 0 {
+ // no error in response body, might happen in HEAD requests
+ err = serviceErrFromStatusCode(resp.StatusCode, resp.Status, requestID, date, version)
+ return respToRet, req, resp, err
+ }
+ // try unmarshal as odata.error json
+ err = json.Unmarshal(respBody, &respToRet.odata)
+ }
+
+ return respToRet, req, resp, err
+}
+
+func (c Client) execInternalJSON(verb, url string, headers map[string]string, body io.Reader, auth authentication) (*odataResponse, error) {
+ respToRet, _, _, err := c.execInternalJSONCommon(verb, url, headers, body, auth)
+ return respToRet, err
+}
+
+func (c Client) execBatchOperationJSON(verb, url string, headers map[string]string, body io.Reader, auth authentication) (*odataResponse, error) {
+ // execute common query, get back generated request, response etc... for more processing.
+ respToRet, req, resp, err := c.execInternalJSONCommon(verb, url, headers, body, auth)
+ if err != nil {
+ return nil, err
+ }
+
+ // return the OData in the case of executing batch commands.
+ // In this case we need to read the outer batch boundary and contents.
+ // Then we read the changeset information within the batch
+ var respBody []byte
+ respBody, err = readAndCloseBody(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ // outer multipart body
+ _, batchHeader, err := mime.ParseMediaType(resp.Header["Content-Type"][0])
+ if err != nil {
+ return nil, err
+ }
+
+ // batch details.
+ batchBoundary := batchHeader["boundary"]
+ batchPartBuf, changesetBoundary, err := genBatchReader(batchBoundary, respBody)
+ if err != nil {
+ return nil, err
+ }
+
+ // changeset details.
+ err = genChangesetReader(req, respToRet, batchPartBuf, changesetBoundary)
+ if err != nil {
+ return nil, err
+ }
+
+ return respToRet, nil
+}
+
+func genChangesetReader(req *http.Request, respToRet *odataResponse, batchPartBuf io.Reader, changesetBoundary string) error {
+ changesetMultiReader := multipart.NewReader(batchPartBuf, changesetBoundary)
+ changesetPart, err := changesetMultiReader.NextPart()
+ if err != nil {
+ return err
+ }
+
+ changesetPartBufioReader := bufio.NewReader(changesetPart)
+ changesetResp, err := http.ReadResponse(changesetPartBufioReader, req)
+ if err != nil {
+ return err
+ }
+
+ if changesetResp.StatusCode != http.StatusNoContent {
+ changesetBody, err := readAndCloseBody(changesetResp.Body)
+ err = json.Unmarshal(changesetBody, &respToRet.odata)
+ if err != nil {
+ return err
+ }
+ respToRet.resp = changesetResp
+ }
+
+ return nil
+}
+
+func genBatchReader(batchBoundary string, respBody []byte) (io.Reader, string, error) {
+ respBodyString := string(respBody)
+ respBodyReader := strings.NewReader(respBodyString)
+
+ // reading batchresponse
+ batchMultiReader := multipart.NewReader(respBodyReader, batchBoundary)
+ batchPart, err := batchMultiReader.NextPart()
+ if err != nil {
+ return nil, "", err
+ }
+ batchPartBufioReader := bufio.NewReader(batchPart)
+
+ _, changesetHeader, err := mime.ParseMediaType(batchPart.Header.Get("Content-Type"))
+ if err != nil {
+ return nil, "", err
+ }
+ changesetBoundary := changesetHeader["boundary"]
+ return batchPartBufioReader, changesetBoundary, nil
+}
+
+func readAndCloseBody(body io.ReadCloser) ([]byte, error) {
+ defer body.Close()
+ out, err := ioutil.ReadAll(body)
+ if err == io.EOF {
+ err = nil
+ }
+ return out, err
+}
+
+// reads the response body then closes it
+func drainRespBody(resp *http.Response) {
+ io.Copy(ioutil.Discard, resp.Body)
+ resp.Body.Close()
+}
+
+func serviceErrFromXML(body []byte, storageErr *AzureStorageServiceError) error {
+ if err := xml.Unmarshal(body, storageErr); err != nil {
+ storageErr.Message = fmt.Sprintf("Response body could no be unmarshaled: %v. Body: %v.", err, string(body))
+ return err
+ }
+ return nil
+}
+
+func serviceErrFromJSON(body []byte, storageErr *AzureStorageServiceError) error {
+ odataError := odataErrorWrapper{}
+ if err := json.Unmarshal(body, &odataError); err != nil {
+ storageErr.Message = fmt.Sprintf("Response body could no be unmarshaled: %v. Body: %v.", err, string(body))
+ return err
+ }
+ storageErr.Code = odataError.Err.Code
+ storageErr.Message = odataError.Err.Message.Value
+ storageErr.Lang = odataError.Err.Message.Lang
+ return nil
+}
+
+func serviceErrFromStatusCode(code int, status string, requestID, date, version string) AzureStorageServiceError {
+ return AzureStorageServiceError{
+ StatusCode: code,
+ Code: status,
+ RequestID: requestID,
+ Date: date,
+ APIVersion: version,
+ Message: "no response body was available for error status code",
+ }
+}
+
+func (e AzureStorageServiceError) Error() string {
+ return fmt.Sprintf("storage: service returned error: StatusCode=%d, ErrorCode=%s, ErrorMessage=%s, RequestInitiated=%s, RequestId=%s, API Version=%s, QueryParameterName=%s, QueryParameterValue=%s",
+ e.StatusCode, e.Code, e.Message, e.Date, e.RequestID, e.APIVersion, e.QueryParameterName, e.QueryParameterValue)
+}
+
+// checkRespCode returns UnexpectedStatusError if the given response code is not
+// one of the allowed status codes; otherwise nil.
+func checkRespCode(resp *http.Response, allowed []int) error {
+ for _, v := range allowed {
+ if resp.StatusCode == v {
+ return nil
+ }
+ }
+ err := getErrorFromResponse(resp)
+ return UnexpectedStatusCodeError{
+ allowed: allowed,
+ got: resp.StatusCode,
+ inner: err,
+ }
+}
+
+func (c Client) addMetadataToHeaders(h map[string]string, metadata map[string]string) map[string]string {
+ metadata = c.protectUserAgent(metadata)
+ for k, v := range metadata {
+ h[userDefinedMetadataHeaderPrefix+k] = v
+ }
+ return h
+}
+
+func getDebugHeaders(h http.Header) (requestID, date, version string) {
+ requestID = h.Get("x-ms-request-id")
+ version = h.Get("x-ms-version")
+ date = h.Get("Date")
+ return
+}
+
+func getErrorFromResponse(resp *http.Response) error {
+ respBody, err := readAndCloseBody(resp.Body)
+ if err != nil {
+ return err
+ }
+
+ requestID, date, version := getDebugHeaders(resp.Header)
+ if len(respBody) == 0 {
+ // no error in response body, might happen in HEAD requests
+ err = serviceErrFromStatusCode(resp.StatusCode, resp.Status, requestID, date, version)
+ } else {
+ storageErr := AzureStorageServiceError{
+ StatusCode: resp.StatusCode,
+ RequestID: requestID,
+ Date: date,
+ APIVersion: version,
+ }
+ // response contains storage service error object, unmarshal
+ if resp.Header.Get("Content-Type") == "application/xml" {
+ errIn := serviceErrFromXML(respBody, &storageErr)
+ if err != nil { // error unmarshaling the error response
+ err = errIn
+ }
+ } else {
+ errIn := serviceErrFromJSON(respBody, &storageErr)
+ if err != nil { // error unmarshaling the error response
+ err = errIn
+ }
+ }
+ err = storageErr
+ }
+ return err
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/commonsasuri.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/commonsasuri.go
new file mode 100644
index 00000000000..e898e9bfaf9
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/commonsasuri.go
@@ -0,0 +1,38 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "net/url"
+ "time"
+)
+
+// SASOptions includes options used by SAS URIs for different
+// services and resources.
+type SASOptions struct {
+ APIVersion string
+ Start time.Time
+ Expiry time.Time
+ IP string
+ UseHTTPS bool
+ Identifier string
+}
+
+func addQueryParameter(query url.Values, key, value string) url.Values {
+ if value != "" {
+ query.Add(key, value)
+ }
+ return query
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/container.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/container.go
new file mode 100644
index 00000000000..056473d49a2
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/container.go
@@ -0,0 +1,640 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// Container represents an Azure container.
+type Container struct {
+ bsc *BlobStorageClient
+ Name string `xml:"Name"`
+ Properties ContainerProperties `xml:"Properties"`
+ Metadata map[string]string
+ sasuri url.URL
+}
+
+// Client returns the HTTP client used by the Container reference.
+func (c *Container) Client() *Client {
+ return &c.bsc.client
+}
+
+func (c *Container) buildPath() string {
+ return fmt.Sprintf("/%s", c.Name)
+}
+
+// GetURL gets the canonical URL to the container.
+// This method does not create a publicly accessible URL if the container
+// is private and this method does not check if the blob exists.
+func (c *Container) GetURL() string {
+ container := c.Name
+ if container == "" {
+ container = "$root"
+ }
+ return c.bsc.client.getEndpoint(blobServiceName, pathForResource(container, ""), nil)
+}
+
+// ContainerSASOptions are options to construct a container SAS
+// URI.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+type ContainerSASOptions struct {
+ ContainerSASPermissions
+ OverrideHeaders
+ SASOptions
+}
+
+// ContainerSASPermissions includes the available permissions for
+// a container SAS URI.
+type ContainerSASPermissions struct {
+ BlobServiceSASPermissions
+ List bool
+}
+
+// GetSASURI creates an URL to the container which contains the Shared
+// Access Signature with the specified options.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+func (c *Container) GetSASURI(options ContainerSASOptions) (string, error) {
+ uri := c.GetURL()
+ signedResource := "c"
+ canonicalizedResource, err := c.bsc.client.buildCanonicalizedResource(uri, c.bsc.auth, true)
+ if err != nil {
+ return "", err
+ }
+
+ // build permissions string
+ permissions := options.BlobServiceSASPermissions.buildString()
+ if options.List {
+ permissions += "l"
+ }
+
+ return c.bsc.client.blobAndFileSASURI(options.SASOptions, uri, permissions, canonicalizedResource, signedResource, options.OverrideHeaders)
+}
+
+// ContainerProperties contains various properties of a container returned from
+// various endpoints like ListContainers.
+type ContainerProperties struct {
+ LastModified string `xml:"Last-Modified"`
+ Etag string `xml:"Etag"`
+ LeaseStatus string `xml:"LeaseStatus"`
+ LeaseState string `xml:"LeaseState"`
+ LeaseDuration string `xml:"LeaseDuration"`
+ PublicAccess ContainerAccessType `xml:"PublicAccess"`
+}
+
+// ContainerListResponse contains the response fields from
+// ListContainers call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179352.aspx
+type ContainerListResponse struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Prefix string `xml:"Prefix"`
+ Marker string `xml:"Marker"`
+ NextMarker string `xml:"NextMarker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Containers []Container `xml:"Containers>Container"`
+}
+
+// BlobListResponse contains the response fields from ListBlobs call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd135734.aspx
+type BlobListResponse struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Prefix string `xml:"Prefix"`
+ Marker string `xml:"Marker"`
+ NextMarker string `xml:"NextMarker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Blobs []Blob `xml:"Blobs>Blob"`
+
+ // BlobPrefix is used to traverse blobs as if it were a file system.
+ // It is returned if ListBlobsParameters.Delimiter is specified.
+ // The list here can be thought of as "folders" that may contain
+ // other folders or blobs.
+ BlobPrefixes []string `xml:"Blobs>BlobPrefix>Name"`
+
+ // Delimiter is used to traverse blobs as if it were a file system.
+ // It is returned if ListBlobsParameters.Delimiter is specified.
+ Delimiter string `xml:"Delimiter"`
+}
+
+// IncludeBlobDataset has options to include in a list blobs operation
+type IncludeBlobDataset struct {
+ Snapshots bool
+ Metadata bool
+ UncommittedBlobs bool
+ Copy bool
+}
+
+// ListBlobsParameters defines the set of customizable
+// parameters to make a List Blobs call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd135734.aspx
+type ListBlobsParameters struct {
+ Prefix string
+ Delimiter string
+ Marker string
+ Include *IncludeBlobDataset
+ MaxResults uint
+ Timeout uint
+ RequestID string
+}
+
+func (p ListBlobsParameters) getParameters() url.Values {
+ out := url.Values{}
+
+ if p.Prefix != "" {
+ out.Set("prefix", p.Prefix)
+ }
+ if p.Delimiter != "" {
+ out.Set("delimiter", p.Delimiter)
+ }
+ if p.Marker != "" {
+ out.Set("marker", p.Marker)
+ }
+ if p.Include != nil {
+ include := []string{}
+ include = addString(include, p.Include.Snapshots, "snapshots")
+ include = addString(include, p.Include.Metadata, "metadata")
+ include = addString(include, p.Include.UncommittedBlobs, "uncommittedblobs")
+ include = addString(include, p.Include.Copy, "copy")
+ fullInclude := strings.Join(include, ",")
+ out.Set("include", fullInclude)
+ }
+ if p.MaxResults != 0 {
+ out.Set("maxresults", strconv.FormatUint(uint64(p.MaxResults), 10))
+ }
+ if p.Timeout != 0 {
+ out.Set("timeout", strconv.FormatUint(uint64(p.Timeout), 10))
+ }
+
+ return out
+}
+
+func addString(datasets []string, include bool, text string) []string {
+ if include {
+ datasets = append(datasets, text)
+ }
+ return datasets
+}
+
+// ContainerAccessType defines the access level to the container from a public
+// request.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179468.aspx and "x-ms-
+// blob-public-access" header.
+type ContainerAccessType string
+
+// Access options for containers
+const (
+ ContainerAccessTypePrivate ContainerAccessType = ""
+ ContainerAccessTypeBlob ContainerAccessType = "blob"
+ ContainerAccessTypeContainer ContainerAccessType = "container"
+)
+
+// ContainerAccessPolicy represents each access policy in the container ACL.
+type ContainerAccessPolicy struct {
+ ID string
+ StartTime time.Time
+ ExpiryTime time.Time
+ CanRead bool
+ CanWrite bool
+ CanDelete bool
+}
+
+// ContainerPermissions represents the container ACLs.
+type ContainerPermissions struct {
+ AccessType ContainerAccessType
+ AccessPolicies []ContainerAccessPolicy
+}
+
+// ContainerAccessHeader references header used when setting/getting container ACL
+const (
+ ContainerAccessHeader string = "x-ms-blob-public-access"
+)
+
+// GetBlobReference returns a Blob object for the specified blob name.
+func (c *Container) GetBlobReference(name string) *Blob {
+ return &Blob{
+ Container: c,
+ Name: name,
+ }
+}
+
+// CreateContainerOptions includes the options for a create container operation
+type CreateContainerOptions struct {
+ Timeout uint
+ Access ContainerAccessType `header:"x-ms-blob-public-access"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Create creates a blob container within the storage account
+// with given name and access level. Returns error if container already exists.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Create-Container
+func (c *Container) Create(options *CreateContainerOptions) error {
+ resp, err := c.create(options)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusCreated})
+}
+
+// CreateIfNotExists creates a blob container if it does not exist. Returns
+// true if container is newly created or false if container already exists.
+func (c *Container) CreateIfNotExists(options *CreateContainerOptions) (bool, error) {
+ resp, err := c.create(options)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusCreated || resp.StatusCode == http.StatusConflict {
+ return resp.StatusCode == http.StatusCreated, nil
+ }
+ }
+ return false, err
+}
+
+func (c *Container) create(options *CreateContainerOptions) (*http.Response, error) {
+ query := url.Values{"restype": {"container"}}
+ headers := c.bsc.client.getStandardHeaders()
+ headers = c.bsc.client.addMetadataToHeaders(headers, c.Metadata)
+
+ if options != nil {
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), query)
+
+ return c.bsc.client.exec(http.MethodPut, uri, headers, nil, c.bsc.auth)
+}
+
+// Exists returns true if a container with given name exists
+// on the storage account, otherwise returns false.
+func (c *Container) Exists() (bool, error) {
+ q := url.Values{"restype": {"container"}}
+ var uri string
+ if c.bsc.client.isServiceSASClient() {
+ q = mergeParams(q, c.sasuri.Query())
+ newURI := c.sasuri
+ newURI.RawQuery = q.Encode()
+ uri = newURI.String()
+
+ } else {
+ uri = c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), q)
+ }
+ headers := c.bsc.client.getStandardHeaders()
+
+ resp, err := c.bsc.client.exec(http.MethodHead, uri, headers, nil, c.bsc.auth)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusOK, nil
+ }
+ }
+ return false, err
+}
+
+// SetContainerPermissionOptions includes options for a set container permissions operation
+type SetContainerPermissionOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// SetPermissions sets up container permissions
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-Container-ACL
+func (c *Container) SetPermissions(permissions ContainerPermissions, options *SetContainerPermissionOptions) error {
+ body, length, err := generateContainerACLpayload(permissions.AccessPolicies)
+ if err != nil {
+ return err
+ }
+ params := url.Values{
+ "restype": {"container"},
+ "comp": {"acl"},
+ }
+ headers := c.bsc.client.getStandardHeaders()
+ headers = addToHeaders(headers, ContainerAccessHeader, string(permissions.AccessType))
+ headers["Content-Length"] = strconv.Itoa(length)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), params)
+
+ resp, err := c.bsc.client.exec(http.MethodPut, uri, headers, body, c.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusOK})
+}
+
+// GetContainerPermissionOptions includes options for a get container permissions operation
+type GetContainerPermissionOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// GetPermissions gets the container permissions as per https://msdn.microsoft.com/en-us/library/azure/dd179469.aspx
+// If timeout is 0 then it will not be passed to Azure
+// leaseID will only be passed to Azure if populated
+func (c *Container) GetPermissions(options *GetContainerPermissionOptions) (*ContainerPermissions, error) {
+ params := url.Values{
+ "restype": {"container"},
+ "comp": {"acl"},
+ }
+ headers := c.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), params)
+
+ resp, err := c.bsc.client.exec(http.MethodGet, uri, headers, nil, c.bsc.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ var ap AccessPolicy
+ err = xmlUnmarshal(resp.Body, &ap.SignedIdentifiersList)
+ if err != nil {
+ return nil, err
+ }
+ return buildAccessPolicy(ap, &resp.Header), nil
+}
+
+func buildAccessPolicy(ap AccessPolicy, headers *http.Header) *ContainerPermissions {
+ // containerAccess. Blob, Container, empty
+ containerAccess := headers.Get(http.CanonicalHeaderKey(ContainerAccessHeader))
+ permissions := ContainerPermissions{
+ AccessType: ContainerAccessType(containerAccess),
+ AccessPolicies: []ContainerAccessPolicy{},
+ }
+
+ for _, policy := range ap.SignedIdentifiersList.SignedIdentifiers {
+ capd := ContainerAccessPolicy{
+ ID: policy.ID,
+ StartTime: policy.AccessPolicy.StartTime,
+ ExpiryTime: policy.AccessPolicy.ExpiryTime,
+ }
+ capd.CanRead = updatePermissions(policy.AccessPolicy.Permission, "r")
+ capd.CanWrite = updatePermissions(policy.AccessPolicy.Permission, "w")
+ capd.CanDelete = updatePermissions(policy.AccessPolicy.Permission, "d")
+
+ permissions.AccessPolicies = append(permissions.AccessPolicies, capd)
+ }
+ return &permissions
+}
+
+// DeleteContainerOptions includes options for a delete container operation
+type DeleteContainerOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Delete deletes the container with given name on the storage
+// account. If the container does not exist returns error.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/delete-container
+func (c *Container) Delete(options *DeleteContainerOptions) error {
+ resp, err := c.delete(options)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusAccepted})
+}
+
+// DeleteIfExists deletes the container with given name on the storage
+// account if it exists. Returns true if container is deleted with this call, or
+// false if the container did not exist at the time of the Delete Container
+// operation.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/delete-container
+func (c *Container) DeleteIfExists(options *DeleteContainerOptions) (bool, error) {
+ resp, err := c.delete(options)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusAccepted || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusAccepted, nil
+ }
+ }
+ return false, err
+}
+
+func (c *Container) delete(options *DeleteContainerOptions) (*http.Response, error) {
+ query := url.Values{"restype": {"container"}}
+ headers := c.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), query)
+
+ return c.bsc.client.exec(http.MethodDelete, uri, headers, nil, c.bsc.auth)
+}
+
+// ListBlobs returns an object that contains list of blobs in the container,
+// pagination token and other information in the response of List Blobs call.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Blobs
+func (c *Container) ListBlobs(params ListBlobsParameters) (BlobListResponse, error) {
+ q := mergeParams(params.getParameters(), url.Values{
+ "restype": {"container"},
+ "comp": {"list"},
+ })
+ var uri string
+ if c.bsc.client.isServiceSASClient() {
+ q = mergeParams(q, c.sasuri.Query())
+ newURI := c.sasuri
+ newURI.RawQuery = q.Encode()
+ uri = newURI.String()
+ } else {
+ uri = c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), q)
+ }
+
+ headers := c.bsc.client.getStandardHeaders()
+ headers = addToHeaders(headers, "x-ms-client-request-id", params.RequestID)
+
+ var out BlobListResponse
+ resp, err := c.bsc.client.exec(http.MethodGet, uri, headers, nil, c.bsc.auth)
+ if err != nil {
+ return out, err
+ }
+ defer resp.Body.Close()
+
+ err = xmlUnmarshal(resp.Body, &out)
+ for i := range out.Blobs {
+ out.Blobs[i].Container = c
+ }
+ return out, err
+}
+
+// ContainerMetadataOptions includes options for container metadata operations
+type ContainerMetadataOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// SetMetadata replaces the metadata for the specified container.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetBlobMetadata. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/set-container-metadata
+func (c *Container) SetMetadata(options *ContainerMetadataOptions) error {
+ params := url.Values{
+ "comp": {"metadata"},
+ "restype": {"container"},
+ }
+ headers := c.bsc.client.getStandardHeaders()
+ headers = c.bsc.client.addMetadataToHeaders(headers, c.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+
+ uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), params)
+
+ resp, err := c.bsc.client.exec(http.MethodPut, uri, headers, nil, c.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusOK})
+}
+
+// GetMetadata returns all user-defined metadata for the specified container.
+//
+// All metadata keys will be returned in lower case. (HTTP header
+// names are case-insensitive.)
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/get-container-metadata
+func (c *Container) GetMetadata(options *ContainerMetadataOptions) error {
+ params := url.Values{
+ "comp": {"metadata"},
+ "restype": {"container"},
+ }
+ headers := c.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+
+ uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), params)
+
+ resp, err := c.bsc.client.exec(http.MethodGet, uri, headers, nil, c.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return err
+ }
+
+ c.writeMetadata(resp.Header)
+ return nil
+}
+
+func (c *Container) writeMetadata(h http.Header) {
+ c.Metadata = writeMetadata(h)
+}
+
+func generateContainerACLpayload(policies []ContainerAccessPolicy) (io.Reader, int, error) {
+ sil := SignedIdentifiers{
+ SignedIdentifiers: []SignedIdentifier{},
+ }
+ for _, capd := range policies {
+ permission := capd.generateContainerPermissions()
+ signedIdentifier := convertAccessPolicyToXMLStructs(capd.ID, capd.StartTime, capd.ExpiryTime, permission)
+ sil.SignedIdentifiers = append(sil.SignedIdentifiers, signedIdentifier)
+ }
+ return xmlMarshal(sil)
+}
+
+func (capd *ContainerAccessPolicy) generateContainerPermissions() (permissions string) {
+ // generate the permissions string (rwd).
+ // still want the end user API to have bool flags.
+ permissions = ""
+
+ if capd.CanRead {
+ permissions += "r"
+ }
+
+ if capd.CanWrite {
+ permissions += "w"
+ }
+
+ if capd.CanDelete {
+ permissions += "d"
+ }
+
+ return permissions
+}
+
+// GetProperties updated the properties of the container.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/get-container-properties
+func (c *Container) GetProperties() error {
+ params := url.Values{
+ "restype": {"container"},
+ }
+ headers := c.bsc.client.getStandardHeaders()
+
+ uri := c.bsc.client.getEndpoint(blobServiceName, c.buildPath(), params)
+
+ resp, err := c.bsc.client.exec(http.MethodGet, uri, headers, nil, c.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+ if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return err
+ }
+
+ // update properties
+ c.Properties.Etag = resp.Header.Get(headerEtag)
+ c.Properties.LeaseStatus = resp.Header.Get("x-ms-lease-status")
+ c.Properties.LeaseState = resp.Header.Get("x-ms-lease-state")
+ c.Properties.LeaseDuration = resp.Header.Get("x-ms-lease-duration")
+ c.Properties.LastModified = resp.Header.Get("Last-Modified")
+ c.Properties.PublicAccess = ContainerAccessType(resp.Header.Get(ContainerAccessHeader))
+
+ return nil
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/copyblob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/copyblob.go
new file mode 100644
index 00000000000..151e9a51072
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/copyblob.go
@@ -0,0 +1,237 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+)
+
+const (
+ blobCopyStatusPending = "pending"
+ blobCopyStatusSuccess = "success"
+ blobCopyStatusAborted = "aborted"
+ blobCopyStatusFailed = "failed"
+)
+
+// CopyOptions includes the options for a copy blob operation
+type CopyOptions struct {
+ Timeout uint
+ Source CopyOptionsConditions
+ Destiny CopyOptionsConditions
+ RequestID string
+}
+
+// IncrementalCopyOptions includes the options for an incremental copy blob operation
+type IncrementalCopyOptions struct {
+ Timeout uint
+ Destination IncrementalCopyOptionsConditions
+ RequestID string
+}
+
+// CopyOptionsConditions includes some conditional options in a copy blob operation
+type CopyOptionsConditions struct {
+ LeaseID string
+ IfModifiedSince *time.Time
+ IfUnmodifiedSince *time.Time
+ IfMatch string
+ IfNoneMatch string
+}
+
+// IncrementalCopyOptionsConditions includes some conditional options in a copy blob operation
+type IncrementalCopyOptionsConditions struct {
+ IfModifiedSince *time.Time
+ IfUnmodifiedSince *time.Time
+ IfMatch string
+ IfNoneMatch string
+}
+
+// Copy starts a blob copy operation and waits for the operation to
+// complete. sourceBlob parameter must be a canonical URL to the blob (can be
+// obtained using the GetURL method.) There is no SLA on blob copy and therefore
+// this helper method works faster on smaller files.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Copy-Blob
+func (b *Blob) Copy(sourceBlob string, options *CopyOptions) error {
+ copyID, err := b.StartCopy(sourceBlob, options)
+ if err != nil {
+ return err
+ }
+
+ return b.WaitForCopy(copyID)
+}
+
+// StartCopy starts a blob copy operation.
+// sourceBlob parameter must be a canonical URL to the blob (can be
+// obtained using the GetURL method.)
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Copy-Blob
+func (b *Blob) StartCopy(sourceBlob string, options *CopyOptions) (string, error) {
+ params := url.Values{}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-copy-source"] = sourceBlob
+ headers = b.Container.bsc.client.addMetadataToHeaders(headers, b.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = addToHeaders(headers, "x-ms-client-request-id", options.RequestID)
+ // source
+ headers = addToHeaders(headers, "x-ms-source-lease-id", options.Source.LeaseID)
+ headers = addTimeToHeaders(headers, "x-ms-source-if-modified-since", options.Source.IfModifiedSince)
+ headers = addTimeToHeaders(headers, "x-ms-source-if-unmodified-since", options.Source.IfUnmodifiedSince)
+ headers = addToHeaders(headers, "x-ms-source-if-match", options.Source.IfMatch)
+ headers = addToHeaders(headers, "x-ms-source-if-none-match", options.Source.IfNoneMatch)
+ //destiny
+ headers = addToHeaders(headers, "x-ms-lease-id", options.Destiny.LeaseID)
+ headers = addTimeToHeaders(headers, "x-ms-if-modified-since", options.Destiny.IfModifiedSince)
+ headers = addTimeToHeaders(headers, "x-ms-if-unmodified-since", options.Destiny.IfUnmodifiedSince)
+ headers = addToHeaders(headers, "x-ms-if-match", options.Destiny.IfMatch)
+ headers = addToHeaders(headers, "x-ms-if-none-match", options.Destiny.IfNoneMatch)
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return "", err
+ }
+ defer drainRespBody(resp)
+
+ if err := checkRespCode(resp, []int{http.StatusAccepted, http.StatusCreated}); err != nil {
+ return "", err
+ }
+
+ copyID := resp.Header.Get("x-ms-copy-id")
+ if copyID == "" {
+ return "", errors.New("Got empty copy id header")
+ }
+ return copyID, nil
+}
+
+// AbortCopyOptions includes the options for an abort blob operation
+type AbortCopyOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// AbortCopy aborts a BlobCopy which has already been triggered by the StartBlobCopy function.
+// copyID is generated from StartBlobCopy function.
+// currentLeaseID is required IF the destination blob has an active lease on it.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Abort-Copy-Blob
+func (b *Blob) AbortCopy(copyID string, options *AbortCopyOptions) error {
+ params := url.Values{
+ "comp": {"copy"},
+ "copyid": {copyID},
+ }
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-copy-action"] = "abort"
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+// WaitForCopy loops until a BlobCopy operation is completed (or fails with error)
+func (b *Blob) WaitForCopy(copyID string) error {
+ for {
+ err := b.GetProperties(nil)
+ if err != nil {
+ return err
+ }
+
+ if b.Properties.CopyID != copyID {
+ return errBlobCopyIDMismatch
+ }
+
+ switch b.Properties.CopyStatus {
+ case blobCopyStatusSuccess:
+ return nil
+ case blobCopyStatusPending:
+ continue
+ case blobCopyStatusAborted:
+ return errBlobCopyAborted
+ case blobCopyStatusFailed:
+ return fmt.Errorf("storage: blob copy failed. Id=%s Description=%s", b.Properties.CopyID, b.Properties.CopyStatusDescription)
+ default:
+ return fmt.Errorf("storage: unhandled blob copy status: '%s'", b.Properties.CopyStatus)
+ }
+ }
+}
+
+// IncrementalCopyBlob copies a snapshot of a source blob and copies to referring blob
+// sourceBlob parameter must be a valid snapshot URL of the original blob.
+// THe original blob mut be public, or use a Shared Access Signature.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/incremental-copy-blob .
+func (b *Blob) IncrementalCopyBlob(sourceBlobURL string, snapshotTime time.Time, options *IncrementalCopyOptions) (string, error) {
+ params := url.Values{"comp": {"incrementalcopy"}}
+
+ // need formatting to 7 decimal places so it's friendly to Windows and *nix
+ snapshotTimeFormatted := snapshotTime.Format("2006-01-02T15:04:05.0000000Z")
+ u, err := url.Parse(sourceBlobURL)
+ if err != nil {
+ return "", err
+ }
+ query := u.Query()
+ query.Add("snapshot", snapshotTimeFormatted)
+ encodedQuery := query.Encode()
+ encodedQuery = strings.Replace(encodedQuery, "%3A", ":", -1)
+ u.RawQuery = encodedQuery
+ snapshotURL := u.String()
+
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-copy-source"] = snapshotURL
+
+ if options != nil {
+ addTimeout(params, options.Timeout)
+ headers = addToHeaders(headers, "x-ms-client-request-id", options.RequestID)
+ headers = addTimeToHeaders(headers, "x-ms-if-modified-since", options.Destination.IfModifiedSince)
+ headers = addTimeToHeaders(headers, "x-ms-if-unmodified-since", options.Destination.IfUnmodifiedSince)
+ headers = addToHeaders(headers, "x-ms-if-match", options.Destination.IfMatch)
+ headers = addToHeaders(headers, "x-ms-if-none-match", options.Destination.IfNoneMatch)
+ }
+
+ // get URI of destination blob
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return "", err
+ }
+ defer drainRespBody(resp)
+
+ if err := checkRespCode(resp, []int{http.StatusAccepted}); err != nil {
+ return "", err
+ }
+
+ copyID := resp.Header.Get("x-ms-copy-id")
+ if copyID == "" {
+ return "", errors.New("Got empty copy id header")
+ }
+ return copyID, nil
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/directory.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/directory.go
new file mode 100644
index 00000000000..6c0c6caf7d3
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/directory.go
@@ -0,0 +1,238 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "net/http"
+ "net/url"
+ "sync"
+)
+
+// Directory represents a directory on a share.
+type Directory struct {
+ fsc *FileServiceClient
+ Metadata map[string]string
+ Name string `xml:"Name"`
+ parent *Directory
+ Properties DirectoryProperties
+ share *Share
+}
+
+// DirectoryProperties contains various properties of a directory.
+type DirectoryProperties struct {
+ LastModified string `xml:"Last-Modified"`
+ Etag string `xml:"Etag"`
+}
+
+// ListDirsAndFilesParameters defines the set of customizable parameters to
+// make a List Files and Directories call.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Directories-and-Files
+type ListDirsAndFilesParameters struct {
+ Prefix string
+ Marker string
+ MaxResults uint
+ Timeout uint
+}
+
+// DirsAndFilesListResponse contains the response fields from
+// a List Files and Directories call.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Directories-and-Files
+type DirsAndFilesListResponse struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Marker string `xml:"Marker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Directories []Directory `xml:"Entries>Directory"`
+ Files []File `xml:"Entries>File"`
+ NextMarker string `xml:"NextMarker"`
+}
+
+// builds the complete directory path for this directory object.
+func (d *Directory) buildPath() string {
+ path := ""
+ current := d
+ for current.Name != "" {
+ path = "/" + current.Name + path
+ current = current.parent
+ }
+ return d.share.buildPath() + path
+}
+
+// Create this directory in the associated share.
+// If a directory with the same name already exists, the operation fails.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Create-Directory
+func (d *Directory) Create(options *FileRequestOptions) error {
+ // if this is the root directory exit early
+ if d.parent == nil {
+ return nil
+ }
+
+ params := prepareOptions(options)
+ headers, err := d.fsc.createResource(d.buildPath(), resourceDirectory, params, mergeMDIntoExtraHeaders(d.Metadata, nil), []int{http.StatusCreated})
+ if err != nil {
+ return err
+ }
+
+ d.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// CreateIfNotExists creates this directory under the associated share if the
+// directory does not exist. Returns true if the directory is newly created or
+// false if the directory already exists.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Create-Directory
+func (d *Directory) CreateIfNotExists(options *FileRequestOptions) (bool, error) {
+ // if this is the root directory exit early
+ if d.parent == nil {
+ return false, nil
+ }
+
+ params := prepareOptions(options)
+ resp, err := d.fsc.createResourceNoClose(d.buildPath(), resourceDirectory, params, nil)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusCreated || resp.StatusCode == http.StatusConflict {
+ if resp.StatusCode == http.StatusCreated {
+ d.updateEtagAndLastModified(resp.Header)
+ return true, nil
+ }
+
+ return false, d.FetchAttributes(nil)
+ }
+ }
+
+ return false, err
+}
+
+// Delete removes this directory. It must be empty in order to be deleted.
+// If the directory does not exist the operation fails.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-Directory
+func (d *Directory) Delete(options *FileRequestOptions) error {
+ return d.fsc.deleteResource(d.buildPath(), resourceDirectory, options)
+}
+
+// DeleteIfExists removes this directory if it exists.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-Directory
+func (d *Directory) DeleteIfExists(options *FileRequestOptions) (bool, error) {
+ resp, err := d.fsc.deleteResourceNoClose(d.buildPath(), resourceDirectory, options)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusAccepted || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusAccepted, nil
+ }
+ }
+ return false, err
+}
+
+// Exists returns true if this directory exists.
+func (d *Directory) Exists() (bool, error) {
+ exists, headers, err := d.fsc.resourceExists(d.buildPath(), resourceDirectory)
+ if exists {
+ d.updateEtagAndLastModified(headers)
+ }
+ return exists, err
+}
+
+// FetchAttributes retrieves metadata for this directory.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-directory-properties
+func (d *Directory) FetchAttributes(options *FileRequestOptions) error {
+ params := prepareOptions(options)
+ headers, err := d.fsc.getResourceHeaders(d.buildPath(), compNone, resourceDirectory, params, http.MethodHead)
+ if err != nil {
+ return err
+ }
+
+ d.updateEtagAndLastModified(headers)
+ d.Metadata = getMetadataFromHeaders(headers)
+
+ return nil
+}
+
+// GetDirectoryReference returns a child Directory object for this directory.
+func (d *Directory) GetDirectoryReference(name string) *Directory {
+ return &Directory{
+ fsc: d.fsc,
+ Name: name,
+ parent: d,
+ share: d.share,
+ }
+}
+
+// GetFileReference returns a child File object for this directory.
+func (d *Directory) GetFileReference(name string) *File {
+ return &File{
+ fsc: d.fsc,
+ Name: name,
+ parent: d,
+ share: d.share,
+ mutex: &sync.Mutex{},
+ }
+}
+
+// ListDirsAndFiles returns a list of files and directories under this directory.
+// It also contains a pagination token and other response details.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Directories-and-Files
+func (d *Directory) ListDirsAndFiles(params ListDirsAndFilesParameters) (*DirsAndFilesListResponse, error) {
+ q := mergeParams(params.getParameters(), getURLInitValues(compList, resourceDirectory))
+
+ resp, err := d.fsc.listContent(d.buildPath(), q, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ defer resp.Body.Close()
+ var out DirsAndFilesListResponse
+ err = xmlUnmarshal(resp.Body, &out)
+ return &out, err
+}
+
+// SetMetadata replaces the metadata for this directory.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetDirectoryMetadata. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-Directory-Metadata
+func (d *Directory) SetMetadata(options *FileRequestOptions) error {
+ headers, err := d.fsc.setResourceHeaders(d.buildPath(), compMetadata, resourceDirectory, mergeMDIntoExtraHeaders(d.Metadata, nil), options)
+ if err != nil {
+ return err
+ }
+
+ d.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// updates Etag and last modified date
+func (d *Directory) updateEtagAndLastModified(headers http.Header) {
+ d.Properties.Etag = headers.Get("Etag")
+ d.Properties.LastModified = headers.Get("Last-Modified")
+}
+
+// URL gets the canonical URL to this directory.
+// This method does not create a publicly accessible URL if the directory
+// is private and this method does not check if the directory exists.
+func (d *Directory) URL() string {
+ return d.fsc.client.getEndpoint(fileServiceName, d.buildPath(), url.Values{})
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/entity.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/entity.go
new file mode 100644
index 00000000000..07dc0df1f52
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/entity.go
@@ -0,0 +1,466 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bytes"
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+
+ uuid "github.com/satori/go.uuid"
+)
+
+// Annotating as secure for gas scanning
+/* #nosec */
+const (
+ partitionKeyNode = "PartitionKey"
+ rowKeyNode = "RowKey"
+ etagErrorTemplate = "Etag didn't match: %v"
+)
+
+var (
+ errEmptyPayload = errors.New("Empty payload is not a valid metadata level for this operation")
+ errNilPreviousResult = errors.New("The previous results page is nil")
+ errNilNextLink = errors.New("There are no more pages in this query results")
+)
+
+// Entity represents an entity inside an Azure table.
+type Entity struct {
+ Table *Table
+ PartitionKey string
+ RowKey string
+ TimeStamp time.Time
+ OdataMetadata string
+ OdataType string
+ OdataID string
+ OdataEtag string
+ OdataEditLink string
+ Properties map[string]interface{}
+}
+
+// GetEntityReference returns an Entity object with the specified
+// partition key and row key.
+func (t *Table) GetEntityReference(partitionKey, rowKey string) *Entity {
+ return &Entity{
+ PartitionKey: partitionKey,
+ RowKey: rowKey,
+ Table: t,
+ }
+}
+
+// EntityOptions includes options for entity operations.
+type EntityOptions struct {
+ Timeout uint
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// GetEntityOptions includes options for a get entity operation
+type GetEntityOptions struct {
+ Select []string
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Get gets the referenced entity. Which properties to get can be
+// specified using the select option.
+// See:
+// https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/query-entities
+// https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/querying-tables-and-entities
+func (e *Entity) Get(timeout uint, ml MetadataLevel, options *GetEntityOptions) error {
+ if ml == EmptyPayload {
+ return errEmptyPayload
+ }
+ // RowKey and PartitionKey could be lost if not included in the query
+ // As those are the entity identifiers, it is best if they are not lost
+ rk := e.RowKey
+ pk := e.PartitionKey
+
+ query := url.Values{
+ "timeout": {strconv.FormatUint(uint64(timeout), 10)},
+ }
+ headers := e.Table.tsc.client.getStandardHeaders()
+ headers[headerAccept] = string(ml)
+
+ if options != nil {
+ if len(options.Select) > 0 {
+ query.Add("$select", strings.Join(options.Select, ","))
+ }
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+
+ uri := e.Table.tsc.client.getEndpoint(tableServiceName, e.buildPath(), query)
+ resp, err := e.Table.tsc.client.exec(http.MethodGet, uri, headers, nil, e.Table.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return err
+ }
+
+ respBody, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+ err = json.Unmarshal(respBody, e)
+ if err != nil {
+ return err
+ }
+ e.PartitionKey = pk
+ e.RowKey = rk
+
+ return nil
+}
+
+// Insert inserts the referenced entity in its table.
+// The function fails if there is an entity with the same
+// PartitionKey and RowKey in the table.
+// ml determines the level of detail of metadata in the operation response,
+// or no data at all.
+// See: https://docs.microsoft.com/rest/api/storageservices/fileservices/insert-entity
+func (e *Entity) Insert(ml MetadataLevel, options *EntityOptions) error {
+ query, headers := options.getParameters()
+ headers = mergeHeaders(headers, e.Table.tsc.client.getStandardHeaders())
+
+ body, err := json.Marshal(e)
+ if err != nil {
+ return err
+ }
+ headers = addBodyRelatedHeaders(headers, len(body))
+ headers = addReturnContentHeaders(headers, ml)
+
+ uri := e.Table.tsc.client.getEndpoint(tableServiceName, e.Table.buildPath(), query)
+ resp, err := e.Table.tsc.client.exec(http.MethodPost, uri, headers, bytes.NewReader(body), e.Table.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if ml != EmptyPayload {
+ if err = checkRespCode(resp, []int{http.StatusCreated}); err != nil {
+ return err
+ }
+ data, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+ if err = e.UnmarshalJSON(data); err != nil {
+ return err
+ }
+ } else {
+ if err = checkRespCode(resp, []int{http.StatusNoContent}); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// Update updates the contents of an entity. The function fails if there is no entity
+// with the same PartitionKey and RowKey in the table or if the ETag is different
+// than the one in Azure.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/update-entity2
+func (e *Entity) Update(force bool, options *EntityOptions) error {
+ return e.updateMerge(force, http.MethodPut, options)
+}
+
+// Merge merges the contents of entity specified with PartitionKey and RowKey
+// with the content specified in Properties.
+// The function fails if there is no entity with the same PartitionKey and
+// RowKey in the table or if the ETag is different than the one in Azure.
+// Read more: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/merge-entity
+func (e *Entity) Merge(force bool, options *EntityOptions) error {
+ return e.updateMerge(force, "MERGE", options)
+}
+
+// Delete deletes the entity.
+// The function fails if there is no entity with the same PartitionKey and
+// RowKey in the table or if the ETag is different than the one in Azure.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/delete-entity1
+func (e *Entity) Delete(force bool, options *EntityOptions) error {
+ query, headers := options.getParameters()
+ headers = mergeHeaders(headers, e.Table.tsc.client.getStandardHeaders())
+
+ headers = addIfMatchHeader(headers, force, e.OdataEtag)
+ headers = addReturnContentHeaders(headers, EmptyPayload)
+
+ uri := e.Table.tsc.client.getEndpoint(tableServiceName, e.buildPath(), query)
+ resp, err := e.Table.tsc.client.exec(http.MethodDelete, uri, headers, nil, e.Table.tsc.auth)
+ if err != nil {
+ if resp != nil && resp.StatusCode == http.StatusPreconditionFailed {
+ return fmt.Errorf(etagErrorTemplate, err)
+ }
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if err = checkRespCode(resp, []int{http.StatusNoContent}); err != nil {
+ return err
+ }
+
+ return e.updateTimestamp(resp.Header)
+}
+
+// InsertOrReplace inserts an entity or replaces the existing one.
+// Read more: https://docs.microsoft.com/rest/api/storageservices/fileservices/insert-or-replace-entity
+func (e *Entity) InsertOrReplace(options *EntityOptions) error {
+ return e.insertOr(http.MethodPut, options)
+}
+
+// InsertOrMerge inserts an entity or merges the existing one.
+// Read more: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/insert-or-merge-entity
+func (e *Entity) InsertOrMerge(options *EntityOptions) error {
+ return e.insertOr("MERGE", options)
+}
+
+func (e *Entity) buildPath() string {
+ return fmt.Sprintf("%s(PartitionKey='%s',RowKey='%s')", e.Table.buildPath(), e.PartitionKey, e.RowKey)
+}
+
+// MarshalJSON is a custom marshaller for entity
+func (e *Entity) MarshalJSON() ([]byte, error) {
+ completeMap := map[string]interface{}{}
+ completeMap[partitionKeyNode] = e.PartitionKey
+ completeMap[rowKeyNode] = e.RowKey
+ for k, v := range e.Properties {
+ typeKey := strings.Join([]string{k, OdataTypeSuffix}, "")
+ switch t := v.(type) {
+ case []byte:
+ completeMap[typeKey] = OdataBinary
+ completeMap[k] = t
+ case time.Time:
+ completeMap[typeKey] = OdataDateTime
+ completeMap[k] = t.Format(time.RFC3339Nano)
+ case uuid.UUID:
+ completeMap[typeKey] = OdataGUID
+ completeMap[k] = t.String()
+ case int64:
+ completeMap[typeKey] = OdataInt64
+ completeMap[k] = fmt.Sprintf("%v", v)
+ case float32, float64:
+ completeMap[typeKey] = OdataDouble
+ completeMap[k] = fmt.Sprintf("%v", v)
+ default:
+ completeMap[k] = v
+ }
+ if strings.HasSuffix(k, OdataTypeSuffix) {
+ if !(completeMap[k] == OdataBinary ||
+ completeMap[k] == OdataDateTime ||
+ completeMap[k] == OdataGUID ||
+ completeMap[k] == OdataInt64 ||
+ completeMap[k] == OdataDouble) {
+ return nil, fmt.Errorf("Odata.type annotation %v value is not valid", k)
+ }
+ valueKey := strings.TrimSuffix(k, OdataTypeSuffix)
+ if _, ok := completeMap[valueKey]; !ok {
+ return nil, fmt.Errorf("Odata.type annotation %v defined without value defined", k)
+ }
+ }
+ }
+ return json.Marshal(completeMap)
+}
+
+// UnmarshalJSON is a custom unmarshaller for entities
+func (e *Entity) UnmarshalJSON(data []byte) error {
+ errorTemplate := "Deserializing error: %v"
+
+ props := map[string]interface{}{}
+ err := json.Unmarshal(data, &props)
+ if err != nil {
+ return err
+ }
+
+ // deselialize metadata
+ e.OdataMetadata = stringFromMap(props, "odata.metadata")
+ e.OdataType = stringFromMap(props, "odata.type")
+ e.OdataID = stringFromMap(props, "odata.id")
+ e.OdataEtag = stringFromMap(props, "odata.etag")
+ e.OdataEditLink = stringFromMap(props, "odata.editLink")
+ e.PartitionKey = stringFromMap(props, partitionKeyNode)
+ e.RowKey = stringFromMap(props, rowKeyNode)
+
+ // deserialize timestamp
+ timeStamp, ok := props["Timestamp"]
+ if ok {
+ str, ok := timeStamp.(string)
+ if !ok {
+ return fmt.Errorf(errorTemplate, "Timestamp casting error")
+ }
+ t, err := time.Parse(time.RFC3339Nano, str)
+ if err != nil {
+ return fmt.Errorf(errorTemplate, err)
+ }
+ e.TimeStamp = t
+ }
+ delete(props, "Timestamp")
+ delete(props, "Timestamp@odata.type")
+
+ // deserialize entity (user defined fields)
+ for k, v := range props {
+ if strings.HasSuffix(k, OdataTypeSuffix) {
+ valueKey := strings.TrimSuffix(k, OdataTypeSuffix)
+ str, ok := props[valueKey].(string)
+ if !ok {
+ return fmt.Errorf(errorTemplate, fmt.Sprintf("%v casting error", v))
+ }
+ switch v {
+ case OdataBinary:
+ props[valueKey], err = base64.StdEncoding.DecodeString(str)
+ if err != nil {
+ return fmt.Errorf(errorTemplate, err)
+ }
+ case OdataDateTime:
+ t, err := time.Parse("2006-01-02T15:04:05Z", str)
+ if err != nil {
+ return fmt.Errorf(errorTemplate, err)
+ }
+ props[valueKey] = t
+ case OdataGUID:
+ props[valueKey] = uuid.FromStringOrNil(str)
+ case OdataInt64:
+ i, err := strconv.ParseInt(str, 10, 64)
+ if err != nil {
+ return fmt.Errorf(errorTemplate, err)
+ }
+ props[valueKey] = i
+ case OdataDouble:
+ f, err := strconv.ParseFloat(str, 64)
+ if err != nil {
+ return fmt.Errorf(errorTemplate, err)
+ }
+ props[valueKey] = f
+ default:
+ return fmt.Errorf(errorTemplate, fmt.Sprintf("%v is not supported", v))
+ }
+ delete(props, k)
+ }
+ }
+
+ e.Properties = props
+ return nil
+}
+
+func getAndDelete(props map[string]interface{}, key string) interface{} {
+ if value, ok := props[key]; ok {
+ delete(props, key)
+ return value
+ }
+ return nil
+}
+
+func addIfMatchHeader(h map[string]string, force bool, etag string) map[string]string {
+ if force {
+ h[headerIfMatch] = "*"
+ } else {
+ h[headerIfMatch] = etag
+ }
+ return h
+}
+
+// updates Etag and timestamp
+func (e *Entity) updateEtagAndTimestamp(headers http.Header) error {
+ e.OdataEtag = headers.Get(headerEtag)
+ return e.updateTimestamp(headers)
+}
+
+func (e *Entity) updateTimestamp(headers http.Header) error {
+ str := headers.Get(headerDate)
+ t, err := time.Parse(time.RFC1123, str)
+ if err != nil {
+ return fmt.Errorf("Update timestamp error: %v", err)
+ }
+ e.TimeStamp = t
+ return nil
+}
+
+func (e *Entity) insertOr(verb string, options *EntityOptions) error {
+ query, headers := options.getParameters()
+ headers = mergeHeaders(headers, e.Table.tsc.client.getStandardHeaders())
+
+ body, err := json.Marshal(e)
+ if err != nil {
+ return err
+ }
+ headers = addBodyRelatedHeaders(headers, len(body))
+ headers = addReturnContentHeaders(headers, EmptyPayload)
+
+ uri := e.Table.tsc.client.getEndpoint(tableServiceName, e.buildPath(), query)
+ resp, err := e.Table.tsc.client.exec(verb, uri, headers, bytes.NewReader(body), e.Table.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if err = checkRespCode(resp, []int{http.StatusNoContent}); err != nil {
+ return err
+ }
+
+ return e.updateEtagAndTimestamp(resp.Header)
+}
+
+func (e *Entity) updateMerge(force bool, verb string, options *EntityOptions) error {
+ query, headers := options.getParameters()
+ headers = mergeHeaders(headers, e.Table.tsc.client.getStandardHeaders())
+
+ body, err := json.Marshal(e)
+ if err != nil {
+ return err
+ }
+ headers = addBodyRelatedHeaders(headers, len(body))
+ headers = addIfMatchHeader(headers, force, e.OdataEtag)
+ headers = addReturnContentHeaders(headers, EmptyPayload)
+
+ uri := e.Table.tsc.client.getEndpoint(tableServiceName, e.buildPath(), query)
+ resp, err := e.Table.tsc.client.exec(verb, uri, headers, bytes.NewReader(body), e.Table.tsc.auth)
+ if err != nil {
+ if resp != nil && resp.StatusCode == http.StatusPreconditionFailed {
+ return fmt.Errorf(etagErrorTemplate, err)
+ }
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if err = checkRespCode(resp, []int{http.StatusNoContent}); err != nil {
+ return err
+ }
+
+ return e.updateEtagAndTimestamp(resp.Header)
+}
+
+func stringFromMap(props map[string]interface{}, key string) string {
+ value := getAndDelete(props, key)
+ if value != nil {
+ return value.(string)
+ }
+ return ""
+}
+
+func (options *EntityOptions) getParameters() (url.Values, map[string]string) {
+ query := url.Values{}
+ headers := map[string]string{}
+ if options != nil {
+ query = addTimeout(query, options.Timeout)
+ headers = headersFromStruct(*options)
+ }
+ return query, headers
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/file.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/file.go
new file mode 100644
index 00000000000..6a480b12a80
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/file.go
@@ -0,0 +1,484 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strconv"
+ "sync"
+)
+
+const fourMB = uint64(4194304)
+const oneTB = uint64(1099511627776)
+
+// Export maximum range and file sizes
+
+// MaxRangeSize defines the maximum size in bytes for a file range.
+const MaxRangeSize = fourMB
+
+// MaxFileSize defines the maximum size in bytes for a file.
+const MaxFileSize = oneTB
+
+// File represents a file on a share.
+type File struct {
+ fsc *FileServiceClient
+ Metadata map[string]string
+ Name string `xml:"Name"`
+ parent *Directory
+ Properties FileProperties `xml:"Properties"`
+ share *Share
+ FileCopyProperties FileCopyState
+ mutex *sync.Mutex
+}
+
+// FileProperties contains various properties of a file.
+type FileProperties struct {
+ CacheControl string `header:"x-ms-cache-control"`
+ Disposition string `header:"x-ms-content-disposition"`
+ Encoding string `header:"x-ms-content-encoding"`
+ Etag string
+ Language string `header:"x-ms-content-language"`
+ LastModified string
+ Length uint64 `xml:"Content-Length" header:"x-ms-content-length"`
+ MD5 string `header:"x-ms-content-md5"`
+ Type string `header:"x-ms-content-type"`
+}
+
+// FileCopyState contains various properties of a file copy operation.
+type FileCopyState struct {
+ CompletionTime string
+ ID string `header:"x-ms-copy-id"`
+ Progress string
+ Source string
+ Status string `header:"x-ms-copy-status"`
+ StatusDesc string
+}
+
+// FileStream contains file data returned from a call to GetFile.
+type FileStream struct {
+ Body io.ReadCloser
+ ContentMD5 string
+}
+
+// FileRequestOptions will be passed to misc file operations.
+// Currently just Timeout (in seconds) but could expand.
+type FileRequestOptions struct {
+ Timeout uint // timeout duration in seconds.
+}
+
+func prepareOptions(options *FileRequestOptions) url.Values {
+ params := url.Values{}
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ }
+ return params
+}
+
+// FileRanges contains a list of file range information for a file.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Ranges
+type FileRanges struct {
+ ContentLength uint64
+ LastModified string
+ ETag string
+ FileRanges []FileRange `xml:"Range"`
+}
+
+// FileRange contains range information for a file.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Ranges
+type FileRange struct {
+ Start uint64 `xml:"Start"`
+ End uint64 `xml:"End"`
+}
+
+func (fr FileRange) String() string {
+ return fmt.Sprintf("bytes=%d-%d", fr.Start, fr.End)
+}
+
+// builds the complete file path for this file object
+func (f *File) buildPath() string {
+ return f.parent.buildPath() + "/" + f.Name
+}
+
+// ClearRange releases the specified range of space in a file.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Range
+func (f *File) ClearRange(fileRange FileRange, options *FileRequestOptions) error {
+ var timeout *uint
+ if options != nil {
+ timeout = &options.Timeout
+ }
+ headers, err := f.modifyRange(nil, fileRange, timeout, nil)
+ if err != nil {
+ return err
+ }
+
+ f.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// Create creates a new file or replaces an existing one.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Create-File
+func (f *File) Create(maxSize uint64, options *FileRequestOptions) error {
+ if maxSize > oneTB {
+ return fmt.Errorf("max file size is 1TB")
+ }
+ params := prepareOptions(options)
+ headers := headersFromStruct(f.Properties)
+ headers["x-ms-content-length"] = strconv.FormatUint(maxSize, 10)
+ headers["x-ms-type"] = "file"
+
+ outputHeaders, err := f.fsc.createResource(f.buildPath(), resourceFile, params, mergeMDIntoExtraHeaders(f.Metadata, headers), []int{http.StatusCreated})
+ if err != nil {
+ return err
+ }
+
+ f.Properties.Length = maxSize
+ f.updateEtagAndLastModified(outputHeaders)
+ return nil
+}
+
+// CopyFile operation copied a file/blob from the sourceURL to the path provided.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/copy-file
+func (f *File) CopyFile(sourceURL string, options *FileRequestOptions) error {
+ extraHeaders := map[string]string{
+ "x-ms-type": "file",
+ "x-ms-copy-source": sourceURL,
+ }
+ params := prepareOptions(options)
+
+ headers, err := f.fsc.createResource(f.buildPath(), resourceFile, params, mergeMDIntoExtraHeaders(f.Metadata, extraHeaders), []int{http.StatusAccepted})
+ if err != nil {
+ return err
+ }
+
+ f.updateEtagAndLastModified(headers)
+ f.FileCopyProperties.ID = headers.Get("X-Ms-Copy-Id")
+ f.FileCopyProperties.Status = headers.Get("X-Ms-Copy-Status")
+ return nil
+}
+
+// Delete immediately removes this file from the storage account.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-File2
+func (f *File) Delete(options *FileRequestOptions) error {
+ return f.fsc.deleteResource(f.buildPath(), resourceFile, options)
+}
+
+// DeleteIfExists removes this file if it exists.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-File2
+func (f *File) DeleteIfExists(options *FileRequestOptions) (bool, error) {
+ resp, err := f.fsc.deleteResourceNoClose(f.buildPath(), resourceFile, options)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusAccepted || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusAccepted, nil
+ }
+ }
+ return false, err
+}
+
+// GetFileOptions includes options for a get file operation
+type GetFileOptions struct {
+ Timeout uint
+ GetContentMD5 bool
+}
+
+// DownloadToStream operation downloads the file.
+//
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-file
+func (f *File) DownloadToStream(options *FileRequestOptions) (io.ReadCloser, error) {
+ params := prepareOptions(options)
+ resp, err := f.fsc.getResourceNoClose(f.buildPath(), compNone, resourceFile, params, http.MethodGet, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ drainRespBody(resp)
+ return nil, err
+ }
+ return resp.Body, nil
+}
+
+// DownloadRangeToStream operation downloads the specified range of this file with optional MD5 hash.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-file
+func (f *File) DownloadRangeToStream(fileRange FileRange, options *GetFileOptions) (fs FileStream, err error) {
+ extraHeaders := map[string]string{
+ "Range": fileRange.String(),
+ }
+ params := url.Values{}
+ if options != nil {
+ if options.GetContentMD5 {
+ if isRangeTooBig(fileRange) {
+ return fs, fmt.Errorf("must specify a range less than or equal to 4MB when getContentMD5 is true")
+ }
+ extraHeaders["x-ms-range-get-content-md5"] = "true"
+ }
+ params = addTimeout(params, options.Timeout)
+ }
+
+ resp, err := f.fsc.getResourceNoClose(f.buildPath(), compNone, resourceFile, params, http.MethodGet, extraHeaders)
+ if err != nil {
+ return fs, err
+ }
+
+ if err = checkRespCode(resp, []int{http.StatusOK, http.StatusPartialContent}); err != nil {
+ drainRespBody(resp)
+ return fs, err
+ }
+
+ fs.Body = resp.Body
+ if options != nil && options.GetContentMD5 {
+ fs.ContentMD5 = resp.Header.Get("Content-MD5")
+ }
+ return fs, nil
+}
+
+// Exists returns true if this file exists.
+func (f *File) Exists() (bool, error) {
+ exists, headers, err := f.fsc.resourceExists(f.buildPath(), resourceFile)
+ if exists {
+ f.updateEtagAndLastModified(headers)
+ f.updateProperties(headers)
+ }
+ return exists, err
+}
+
+// FetchAttributes updates metadata and properties for this file.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-file-properties
+func (f *File) FetchAttributes(options *FileRequestOptions) error {
+ params := prepareOptions(options)
+ headers, err := f.fsc.getResourceHeaders(f.buildPath(), compNone, resourceFile, params, http.MethodHead)
+ if err != nil {
+ return err
+ }
+
+ f.updateEtagAndLastModified(headers)
+ f.updateProperties(headers)
+ f.Metadata = getMetadataFromHeaders(headers)
+ return nil
+}
+
+// returns true if the range is larger than 4MB
+func isRangeTooBig(fileRange FileRange) bool {
+ if fileRange.End-fileRange.Start > fourMB {
+ return true
+ }
+
+ return false
+}
+
+// ListRangesOptions includes options for a list file ranges operation
+type ListRangesOptions struct {
+ Timeout uint
+ ListRange *FileRange
+}
+
+// ListRanges returns the list of valid ranges for this file.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Ranges
+func (f *File) ListRanges(options *ListRangesOptions) (*FileRanges, error) {
+ params := url.Values{"comp": {"rangelist"}}
+
+ // add optional range to list
+ var headers map[string]string
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ if options.ListRange != nil {
+ headers = make(map[string]string)
+ headers["Range"] = options.ListRange.String()
+ }
+ }
+
+ resp, err := f.fsc.listContent(f.buildPath(), params, headers)
+ if err != nil {
+ return nil, err
+ }
+
+ defer resp.Body.Close()
+ var cl uint64
+ cl, err = strconv.ParseUint(resp.Header.Get("x-ms-content-length"), 10, 64)
+ if err != nil {
+ ioutil.ReadAll(resp.Body)
+ return nil, err
+ }
+
+ var out FileRanges
+ out.ContentLength = cl
+ out.ETag = resp.Header.Get("ETag")
+ out.LastModified = resp.Header.Get("Last-Modified")
+
+ err = xmlUnmarshal(resp.Body, &out)
+ return &out, err
+}
+
+// modifies a range of bytes in this file
+func (f *File) modifyRange(bytes io.Reader, fileRange FileRange, timeout *uint, contentMD5 *string) (http.Header, error) {
+ if err := f.fsc.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+ if fileRange.End < fileRange.Start {
+ return nil, errors.New("the value for rangeEnd must be greater than or equal to rangeStart")
+ }
+ if bytes != nil && isRangeTooBig(fileRange) {
+ return nil, errors.New("range cannot exceed 4MB in size")
+ }
+
+ params := url.Values{"comp": {"range"}}
+ if timeout != nil {
+ params = addTimeout(params, *timeout)
+ }
+
+ uri := f.fsc.client.getEndpoint(fileServiceName, f.buildPath(), params)
+
+ // default to clear
+ write := "clear"
+ cl := uint64(0)
+
+ // if bytes is not nil then this is an update operation
+ if bytes != nil {
+ write = "update"
+ cl = (fileRange.End - fileRange.Start) + 1
+ }
+
+ extraHeaders := map[string]string{
+ "Content-Length": strconv.FormatUint(cl, 10),
+ "Range": fileRange.String(),
+ "x-ms-write": write,
+ }
+
+ if contentMD5 != nil {
+ extraHeaders["Content-MD5"] = *contentMD5
+ }
+
+ headers := mergeHeaders(f.fsc.client.getStandardHeaders(), extraHeaders)
+ resp, err := f.fsc.client.exec(http.MethodPut, uri, headers, bytes, f.fsc.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer drainRespBody(resp)
+ return resp.Header, checkRespCode(resp, []int{http.StatusCreated})
+}
+
+// SetMetadata replaces the metadata for this file.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetFileMetadata. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-File-Metadata
+func (f *File) SetMetadata(options *FileRequestOptions) error {
+ headers, err := f.fsc.setResourceHeaders(f.buildPath(), compMetadata, resourceFile, mergeMDIntoExtraHeaders(f.Metadata, nil), options)
+ if err != nil {
+ return err
+ }
+
+ f.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// SetProperties sets system properties on this file.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by SetFileProperties. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-File-Properties
+func (f *File) SetProperties(options *FileRequestOptions) error {
+ headers, err := f.fsc.setResourceHeaders(f.buildPath(), compProperties, resourceFile, headersFromStruct(f.Properties), options)
+ if err != nil {
+ return err
+ }
+
+ f.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// updates Etag and last modified date
+func (f *File) updateEtagAndLastModified(headers http.Header) {
+ f.Properties.Etag = headers.Get("Etag")
+ f.Properties.LastModified = headers.Get("Last-Modified")
+}
+
+// updates file properties from the specified HTTP header
+func (f *File) updateProperties(header http.Header) {
+ size, err := strconv.ParseUint(header.Get("Content-Length"), 10, 64)
+ if err == nil {
+ f.Properties.Length = size
+ }
+
+ f.updateEtagAndLastModified(header)
+ f.Properties.CacheControl = header.Get("Cache-Control")
+ f.Properties.Disposition = header.Get("Content-Disposition")
+ f.Properties.Encoding = header.Get("Content-Encoding")
+ f.Properties.Language = header.Get("Content-Language")
+ f.Properties.MD5 = header.Get("Content-MD5")
+ f.Properties.Type = header.Get("Content-Type")
+}
+
+// URL gets the canonical URL to this file.
+// This method does not create a publicly accessible URL if the file
+// is private and this method does not check if the file exists.
+func (f *File) URL() string {
+ return f.fsc.client.getEndpoint(fileServiceName, f.buildPath(), nil)
+}
+
+// WriteRangeOptions includes options for a write file range operation
+type WriteRangeOptions struct {
+ Timeout uint
+ ContentMD5 string
+}
+
+// WriteRange writes a range of bytes to this file with an optional MD5 hash of the content (inside
+// options parameter). Note that the length of bytes must match (rangeEnd - rangeStart) + 1 with
+// a maximum size of 4MB.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Range
+func (f *File) WriteRange(bytes io.Reader, fileRange FileRange, options *WriteRangeOptions) error {
+ if bytes == nil {
+ return errors.New("bytes cannot be nil")
+ }
+ var timeout *uint
+ var md5 *string
+ if options != nil {
+ timeout = &options.Timeout
+ md5 = &options.ContentMD5
+ }
+
+ headers, err := f.modifyRange(bytes, fileRange, timeout, md5)
+ if err != nil {
+ return err
+ }
+ // it's perfectly legal for multiple go routines to call WriteRange
+ // on the same *File (e.g. concurrently writing non-overlapping ranges)
+ // so we must take the file mutex before updating our properties.
+ f.mutex.Lock()
+ f.updateEtagAndLastModified(headers)
+ f.mutex.Unlock()
+ return nil
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/fileserviceclient.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/fileserviceclient.go
new file mode 100644
index 00000000000..1db8e7da610
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/fileserviceclient.go
@@ -0,0 +1,338 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+)
+
+// FileServiceClient contains operations for Microsoft Azure File Service.
+type FileServiceClient struct {
+ client Client
+ auth authentication
+}
+
+// ListSharesParameters defines the set of customizable parameters to make a
+// List Shares call.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Shares
+type ListSharesParameters struct {
+ Prefix string
+ Marker string
+ Include string
+ MaxResults uint
+ Timeout uint
+}
+
+// ShareListResponse contains the response fields from
+// ListShares call.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/List-Shares
+type ShareListResponse struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Prefix string `xml:"Prefix"`
+ Marker string `xml:"Marker"`
+ NextMarker string `xml:"NextMarker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Shares []Share `xml:"Shares>Share"`
+}
+
+type compType string
+
+const (
+ compNone compType = ""
+ compList compType = "list"
+ compMetadata compType = "metadata"
+ compProperties compType = "properties"
+ compRangeList compType = "rangelist"
+)
+
+func (ct compType) String() string {
+ return string(ct)
+}
+
+type resourceType string
+
+const (
+ resourceDirectory resourceType = "directory"
+ resourceFile resourceType = ""
+ resourceShare resourceType = "share"
+)
+
+func (rt resourceType) String() string {
+ return string(rt)
+}
+
+func (p ListSharesParameters) getParameters() url.Values {
+ out := url.Values{}
+
+ if p.Prefix != "" {
+ out.Set("prefix", p.Prefix)
+ }
+ if p.Marker != "" {
+ out.Set("marker", p.Marker)
+ }
+ if p.Include != "" {
+ out.Set("include", p.Include)
+ }
+ if p.MaxResults != 0 {
+ out.Set("maxresults", strconv.FormatUint(uint64(p.MaxResults), 10))
+ }
+ if p.Timeout != 0 {
+ out.Set("timeout", strconv.FormatUint(uint64(p.Timeout), 10))
+ }
+
+ return out
+}
+
+func (p ListDirsAndFilesParameters) getParameters() url.Values {
+ out := url.Values{}
+
+ if p.Prefix != "" {
+ out.Set("prefix", p.Prefix)
+ }
+ if p.Marker != "" {
+ out.Set("marker", p.Marker)
+ }
+ if p.MaxResults != 0 {
+ out.Set("maxresults", strconv.FormatUint(uint64(p.MaxResults), 10))
+ }
+ out = addTimeout(out, p.Timeout)
+
+ return out
+}
+
+// returns url.Values for the specified types
+func getURLInitValues(comp compType, res resourceType) url.Values {
+ values := url.Values{}
+ if comp != compNone {
+ values.Set("comp", comp.String())
+ }
+ if res != resourceFile {
+ values.Set("restype", res.String())
+ }
+ return values
+}
+
+// GetShareReference returns a Share object for the specified share name.
+func (f *FileServiceClient) GetShareReference(name string) *Share {
+ return &Share{
+ fsc: f,
+ Name: name,
+ Properties: ShareProperties{
+ Quota: -1,
+ },
+ }
+}
+
+// ListShares returns the list of shares in a storage account along with
+// pagination token and other response details.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/list-shares
+func (f FileServiceClient) ListShares(params ListSharesParameters) (*ShareListResponse, error) {
+ q := mergeParams(params.getParameters(), url.Values{"comp": {"list"}})
+
+ var out ShareListResponse
+ resp, err := f.listContent("", q, nil)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+ err = xmlUnmarshal(resp.Body, &out)
+
+ // assign our client to the newly created Share objects
+ for i := range out.Shares {
+ out.Shares[i].fsc = &f
+ }
+ return &out, err
+}
+
+// GetServiceProperties gets the properties of your storage account's file service.
+// File service does not support logging
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-file-service-properties
+func (f *FileServiceClient) GetServiceProperties() (*ServiceProperties, error) {
+ return f.client.getServiceProperties(fileServiceName, f.auth)
+}
+
+// SetServiceProperties sets the properties of your storage account's file service.
+// File service does not support logging
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/set-file-service-properties
+func (f *FileServiceClient) SetServiceProperties(props ServiceProperties) error {
+ return f.client.setServiceProperties(props, fileServiceName, f.auth)
+}
+
+// retrieves directory or share content
+func (f FileServiceClient) listContent(path string, params url.Values, extraHeaders map[string]string) (*http.Response, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+
+ uri := f.client.getEndpoint(fileServiceName, path, params)
+ extraHeaders = f.client.protectUserAgent(extraHeaders)
+ headers := mergeHeaders(f.client.getStandardHeaders(), extraHeaders)
+
+ resp, err := f.client.exec(http.MethodGet, uri, headers, nil, f.auth)
+ if err != nil {
+ return nil, err
+ }
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ drainRespBody(resp)
+ return nil, err
+ }
+
+ return resp, nil
+}
+
+// returns true if the specified resource exists
+func (f FileServiceClient) resourceExists(path string, res resourceType) (bool, http.Header, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return false, nil, err
+ }
+
+ uri := f.client.getEndpoint(fileServiceName, path, getURLInitValues(compNone, res))
+ headers := f.client.getStandardHeaders()
+
+ resp, err := f.client.exec(http.MethodHead, uri, headers, nil, f.auth)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusOK, resp.Header, nil
+ }
+ }
+ return false, nil, err
+}
+
+// creates a resource depending on the specified resource type
+func (f FileServiceClient) createResource(path string, res resourceType, urlParams url.Values, extraHeaders map[string]string, expectedResponseCodes []int) (http.Header, error) {
+ resp, err := f.createResourceNoClose(path, res, urlParams, extraHeaders)
+ if err != nil {
+ return nil, err
+ }
+ defer drainRespBody(resp)
+ return resp.Header, checkRespCode(resp, expectedResponseCodes)
+}
+
+// creates a resource depending on the specified resource type, doesn't close the response body
+func (f FileServiceClient) createResourceNoClose(path string, res resourceType, urlParams url.Values, extraHeaders map[string]string) (*http.Response, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+
+ values := getURLInitValues(compNone, res)
+ combinedParams := mergeParams(values, urlParams)
+ uri := f.client.getEndpoint(fileServiceName, path, combinedParams)
+ extraHeaders = f.client.protectUserAgent(extraHeaders)
+ headers := mergeHeaders(f.client.getStandardHeaders(), extraHeaders)
+
+ return f.client.exec(http.MethodPut, uri, headers, nil, f.auth)
+}
+
+// returns HTTP header data for the specified directory or share
+func (f FileServiceClient) getResourceHeaders(path string, comp compType, res resourceType, params url.Values, verb string) (http.Header, error) {
+ resp, err := f.getResourceNoClose(path, comp, res, params, verb, nil)
+ if err != nil {
+ return nil, err
+ }
+ defer drainRespBody(resp)
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ return resp.Header, nil
+}
+
+// gets the specified resource, doesn't close the response body
+func (f FileServiceClient) getResourceNoClose(path string, comp compType, res resourceType, params url.Values, verb string, extraHeaders map[string]string) (*http.Response, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+
+ params = mergeParams(params, getURLInitValues(comp, res))
+ uri := f.client.getEndpoint(fileServiceName, path, params)
+ headers := mergeHeaders(f.client.getStandardHeaders(), extraHeaders)
+
+ return f.client.exec(verb, uri, headers, nil, f.auth)
+}
+
+// deletes the resource and returns the response
+func (f FileServiceClient) deleteResource(path string, res resourceType, options *FileRequestOptions) error {
+ resp, err := f.deleteResourceNoClose(path, res, options)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusAccepted})
+}
+
+// deletes the resource and returns the response, doesn't close the response body
+func (f FileServiceClient) deleteResourceNoClose(path string, res resourceType, options *FileRequestOptions) (*http.Response, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+
+ values := mergeParams(getURLInitValues(compNone, res), prepareOptions(options))
+ uri := f.client.getEndpoint(fileServiceName, path, values)
+ return f.client.exec(http.MethodDelete, uri, f.client.getStandardHeaders(), nil, f.auth)
+}
+
+// merges metadata into extraHeaders and returns extraHeaders
+func mergeMDIntoExtraHeaders(metadata, extraHeaders map[string]string) map[string]string {
+ if metadata == nil && extraHeaders == nil {
+ return nil
+ }
+ if extraHeaders == nil {
+ extraHeaders = make(map[string]string)
+ }
+ for k, v := range metadata {
+ extraHeaders[userDefinedMetadataHeaderPrefix+k] = v
+ }
+ return extraHeaders
+}
+
+// sets extra header data for the specified resource
+func (f FileServiceClient) setResourceHeaders(path string, comp compType, res resourceType, extraHeaders map[string]string, options *FileRequestOptions) (http.Header, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+
+ params := mergeParams(getURLInitValues(comp, res), prepareOptions(options))
+ uri := f.client.getEndpoint(fileServiceName, path, params)
+ extraHeaders = f.client.protectUserAgent(extraHeaders)
+ headers := mergeHeaders(f.client.getStandardHeaders(), extraHeaders)
+
+ resp, err := f.client.exec(http.MethodPut, uri, headers, nil, f.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer drainRespBody(resp)
+
+ return resp.Header, checkRespCode(resp, []int{http.StatusOK})
+}
+
+//checkForStorageEmulator determines if the client is setup for use with
+//Azure Storage Emulator, and returns a relevant error
+func (f FileServiceClient) checkForStorageEmulator() error {
+ if f.client.accountName == StorageEmulatorAccountName {
+ return fmt.Errorf("Error: File service is not currently supported by Azure Storage Emulator")
+ }
+ return nil
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/leaseblob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/leaseblob.go
new file mode 100644
index 00000000000..5b4a65145b6
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/leaseblob.go
@@ -0,0 +1,201 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "errors"
+ "net/http"
+ "net/url"
+ "strconv"
+ "time"
+)
+
+// lease constants.
+const (
+ leaseHeaderPrefix = "x-ms-lease-"
+ headerLeaseID = "x-ms-lease-id"
+ leaseAction = "x-ms-lease-action"
+ leaseBreakPeriod = "x-ms-lease-break-period"
+ leaseDuration = "x-ms-lease-duration"
+ leaseProposedID = "x-ms-proposed-lease-id"
+ leaseTime = "x-ms-lease-time"
+
+ acquireLease = "acquire"
+ renewLease = "renew"
+ changeLease = "change"
+ releaseLease = "release"
+ breakLease = "break"
+)
+
+// leasePut is common PUT code for the various acquire/release/break etc functions.
+func (b *Blob) leaseCommonPut(headers map[string]string, expectedStatus int, options *LeaseOptions) (http.Header, error) {
+ params := url.Values{"comp": {"lease"}}
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer drainRespBody(resp)
+
+ if err := checkRespCode(resp, []int{expectedStatus}); err != nil {
+ return nil, err
+ }
+
+ return resp.Header, nil
+}
+
+// LeaseOptions includes options for all operations regarding leasing blobs
+type LeaseOptions struct {
+ Timeout uint
+ Origin string `header:"Origin"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// AcquireLease creates a lease for a blob
+// returns leaseID acquired
+// In API Versions starting on 2012-02-12, the minimum leaseTimeInSeconds is 15, the maximum
+// non-infinite leaseTimeInSeconds is 60. To specify an infinite lease, provide the value -1.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Lease-Blob
+func (b *Blob) AcquireLease(leaseTimeInSeconds int, proposedLeaseID string, options *LeaseOptions) (returnedLeaseID string, err error) {
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers[leaseAction] = acquireLease
+
+ if leaseTimeInSeconds == -1 {
+ // Do nothing, but don't trigger the following clauses.
+ } else if leaseTimeInSeconds > 60 || b.Container.bsc.client.apiVersion < "2012-02-12" {
+ leaseTimeInSeconds = 60
+ } else if leaseTimeInSeconds < 15 {
+ leaseTimeInSeconds = 15
+ }
+
+ headers[leaseDuration] = strconv.Itoa(leaseTimeInSeconds)
+
+ if proposedLeaseID != "" {
+ headers[leaseProposedID] = proposedLeaseID
+ }
+
+ respHeaders, err := b.leaseCommonPut(headers, http.StatusCreated, options)
+ if err != nil {
+ return "", err
+ }
+
+ returnedLeaseID = respHeaders.Get(http.CanonicalHeaderKey(headerLeaseID))
+
+ if returnedLeaseID != "" {
+ return returnedLeaseID, nil
+ }
+
+ return "", errors.New("LeaseID not returned")
+}
+
+// BreakLease breaks the lease for a blob
+// Returns the timeout remaining in the lease in seconds
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Lease-Blob
+func (b *Blob) BreakLease(options *LeaseOptions) (breakTimeout int, err error) {
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers[leaseAction] = breakLease
+ return b.breakLeaseCommon(headers, options)
+}
+
+// BreakLeaseWithBreakPeriod breaks the lease for a blob
+// breakPeriodInSeconds is used to determine how long until new lease can be created.
+// Returns the timeout remaining in the lease in seconds
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Lease-Blob
+func (b *Blob) BreakLeaseWithBreakPeriod(breakPeriodInSeconds int, options *LeaseOptions) (breakTimeout int, err error) {
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers[leaseAction] = breakLease
+ headers[leaseBreakPeriod] = strconv.Itoa(breakPeriodInSeconds)
+ return b.breakLeaseCommon(headers, options)
+}
+
+// breakLeaseCommon is common code for both version of BreakLease (with and without break period)
+func (b *Blob) breakLeaseCommon(headers map[string]string, options *LeaseOptions) (breakTimeout int, err error) {
+
+ respHeaders, err := b.leaseCommonPut(headers, http.StatusAccepted, options)
+ if err != nil {
+ return 0, err
+ }
+
+ breakTimeoutStr := respHeaders.Get(http.CanonicalHeaderKey(leaseTime))
+ if breakTimeoutStr != "" {
+ breakTimeout, err = strconv.Atoi(breakTimeoutStr)
+ if err != nil {
+ return 0, err
+ }
+ }
+
+ return breakTimeout, nil
+}
+
+// ChangeLease changes a lease ID for a blob
+// Returns the new LeaseID acquired
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Lease-Blob
+func (b *Blob) ChangeLease(currentLeaseID string, proposedLeaseID string, options *LeaseOptions) (newLeaseID string, err error) {
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers[leaseAction] = changeLease
+ headers[headerLeaseID] = currentLeaseID
+ headers[leaseProposedID] = proposedLeaseID
+
+ respHeaders, err := b.leaseCommonPut(headers, http.StatusOK, options)
+ if err != nil {
+ return "", err
+ }
+
+ newLeaseID = respHeaders.Get(http.CanonicalHeaderKey(headerLeaseID))
+ if newLeaseID != "" {
+ return newLeaseID, nil
+ }
+
+ return "", errors.New("LeaseID not returned")
+}
+
+// ReleaseLease releases the lease for a blob
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Lease-Blob
+func (b *Blob) ReleaseLease(currentLeaseID string, options *LeaseOptions) error {
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers[leaseAction] = releaseLease
+ headers[headerLeaseID] = currentLeaseID
+
+ _, err := b.leaseCommonPut(headers, http.StatusOK, options)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+// RenewLease renews the lease for a blob as per https://msdn.microsoft.com/en-us/library/azure/ee691972.aspx
+func (b *Blob) RenewLease(currentLeaseID string, options *LeaseOptions) error {
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers[leaseAction] = renewLease
+ headers[headerLeaseID] = currentLeaseID
+
+ _, err := b.leaseCommonPut(headers, http.StatusOK, options)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/message.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/message.go
new file mode 100644
index 00000000000..ffc183be619
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/message.go
@@ -0,0 +1,171 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+ "time"
+)
+
+// Message represents an Azure message.
+type Message struct {
+ Queue *Queue
+ Text string `xml:"MessageText"`
+ ID string `xml:"MessageId"`
+ Insertion TimeRFC1123 `xml:"InsertionTime"`
+ Expiration TimeRFC1123 `xml:"ExpirationTime"`
+ PopReceipt string `xml:"PopReceipt"`
+ NextVisible TimeRFC1123 `xml:"TimeNextVisible"`
+ DequeueCount int `xml:"DequeueCount"`
+}
+
+func (m *Message) buildPath() string {
+ return fmt.Sprintf("%s/%s", m.Queue.buildPathMessages(), m.ID)
+}
+
+// PutMessageOptions is the set of options can be specified for Put Messsage
+// operation. A zero struct does not use any preferences for the request.
+type PutMessageOptions struct {
+ Timeout uint
+ VisibilityTimeout int
+ MessageTTL int
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Put operation adds a new message to the back of the message queue.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Message
+func (m *Message) Put(options *PutMessageOptions) error {
+ query := url.Values{}
+ headers := m.Queue.qsc.client.getStandardHeaders()
+
+ req := putMessageRequest{MessageText: m.Text}
+ body, nn, err := xmlMarshal(req)
+ if err != nil {
+ return err
+ }
+ headers["Content-Length"] = strconv.Itoa(nn)
+
+ if options != nil {
+ if options.VisibilityTimeout != 0 {
+ query.Set("visibilitytimeout", strconv.Itoa(options.VisibilityTimeout))
+ }
+ if options.MessageTTL != 0 {
+ query.Set("messagettl", strconv.Itoa(options.MessageTTL))
+ }
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+
+ uri := m.Queue.qsc.client.getEndpoint(queueServiceName, m.Queue.buildPathMessages(), query)
+ resp, err := m.Queue.qsc.client.exec(http.MethodPost, uri, headers, body, m.Queue.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ err = checkRespCode(resp, []int{http.StatusCreated})
+ if err != nil {
+ return err
+ }
+ err = xmlUnmarshal(resp.Body, m)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// UpdateMessageOptions is the set of options can be specified for Update Messsage
+// operation. A zero struct does not use any preferences for the request.
+type UpdateMessageOptions struct {
+ Timeout uint
+ VisibilityTimeout int
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Update operation updates the specified message.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Update-Message
+func (m *Message) Update(options *UpdateMessageOptions) error {
+ query := url.Values{}
+ if m.PopReceipt != "" {
+ query.Set("popreceipt", m.PopReceipt)
+ }
+
+ headers := m.Queue.qsc.client.getStandardHeaders()
+ req := putMessageRequest{MessageText: m.Text}
+ body, nn, err := xmlMarshal(req)
+ if err != nil {
+ return err
+ }
+ headers["Content-Length"] = strconv.Itoa(nn)
+ // visibilitytimeout is required for Update (zero or greater) so set the default here
+ query.Set("visibilitytimeout", "0")
+ if options != nil {
+ if options.VisibilityTimeout != 0 {
+ query.Set("visibilitytimeout", strconv.Itoa(options.VisibilityTimeout))
+ }
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := m.Queue.qsc.client.getEndpoint(queueServiceName, m.buildPath(), query)
+
+ resp, err := m.Queue.qsc.client.exec(http.MethodPut, uri, headers, body, m.Queue.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ m.PopReceipt = resp.Header.Get("x-ms-popreceipt")
+ nextTimeStr := resp.Header.Get("x-ms-time-next-visible")
+ if nextTimeStr != "" {
+ nextTime, err := time.Parse(time.RFC1123, nextTimeStr)
+ if err != nil {
+ return err
+ }
+ m.NextVisible = TimeRFC1123(nextTime)
+ }
+
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+// Delete operation deletes the specified message.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179347.aspx
+func (m *Message) Delete(options *QueueServiceOptions) error {
+ params := url.Values{"popreceipt": {m.PopReceipt}}
+ headers := m.Queue.qsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := m.Queue.qsc.client.getEndpoint(queueServiceName, m.buildPath(), params)
+
+ resp, err := m.Queue.qsc.client.exec(http.MethodDelete, uri, headers, nil, m.Queue.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+type putMessageRequest struct {
+ XMLName xml.Name `xml:"QueueMessage"`
+ MessageText string `xml:"MessageText"`
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/odata.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/odata.go
new file mode 100644
index 00000000000..0690e85ad9b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/odata.go
@@ -0,0 +1,48 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// MetadataLevel determines if operations should return a paylod,
+// and it level of detail.
+type MetadataLevel string
+
+// This consts are meant to help with Odata supported operations
+const (
+ OdataTypeSuffix = "@odata.type"
+
+ // Types
+
+ OdataBinary = "Edm.Binary"
+ OdataDateTime = "Edm.DateTime"
+ OdataDouble = "Edm.Double"
+ OdataGUID = "Edm.Guid"
+ OdataInt64 = "Edm.Int64"
+
+ // Query options
+
+ OdataFilter = "$filter"
+ OdataOrderBy = "$orderby"
+ OdataTop = "$top"
+ OdataSkip = "$skip"
+ OdataCount = "$count"
+ OdataExpand = "$expand"
+ OdataSelect = "$select"
+ OdataSearch = "$search"
+
+ EmptyPayload MetadataLevel = ""
+ NoMetadata MetadataLevel = "application/json;odata=nometadata"
+ MinimalMetadata MetadataLevel = "application/json;odata=minimalmetadata"
+ FullMetadata MetadataLevel = "application/json;odata=fullmetadata"
+)
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/pageblob.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/pageblob.go
new file mode 100644
index 00000000000..7ffd63821d7
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/pageblob.go
@@ -0,0 +1,203 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "time"
+)
+
+// GetPageRangesResponse contains the response fields from
+// Get Page Ranges call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/ee691973.aspx
+type GetPageRangesResponse struct {
+ XMLName xml.Name `xml:"PageList"`
+ PageList []PageRange `xml:"PageRange"`
+}
+
+// PageRange contains information about a page of a page blob from
+// Get Pages Range call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/ee691973.aspx
+type PageRange struct {
+ Start int64 `xml:"Start"`
+ End int64 `xml:"End"`
+}
+
+var (
+ errBlobCopyAborted = errors.New("storage: blob copy is aborted")
+ errBlobCopyIDMismatch = errors.New("storage: blob copy id is a mismatch")
+)
+
+// PutPageOptions includes the options for a put page operation
+type PutPageOptions struct {
+ Timeout uint
+ LeaseID string `header:"x-ms-lease-id"`
+ IfSequenceNumberLessThanOrEqualTo *int `header:"x-ms-if-sequence-number-le"`
+ IfSequenceNumberLessThan *int `header:"x-ms-if-sequence-number-lt"`
+ IfSequenceNumberEqualTo *int `header:"x-ms-if-sequence-number-eq"`
+ IfModifiedSince *time.Time `header:"If-Modified-Since"`
+ IfUnmodifiedSince *time.Time `header:"If-Unmodified-Since"`
+ IfMatch string `header:"If-Match"`
+ IfNoneMatch string `header:"If-None-Match"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// WriteRange writes a range of pages to a page blob.
+// Ranges must be aligned with 512-byte boundaries and chunk must be of size
+// multiplies by 512.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Page
+func (b *Blob) WriteRange(blobRange BlobRange, bytes io.Reader, options *PutPageOptions) error {
+ if bytes == nil {
+ return errors.New("bytes cannot be nil")
+ }
+ return b.modifyRange(blobRange, bytes, options)
+}
+
+// ClearRange clears the given range in a page blob.
+// Ranges must be aligned with 512-byte boundaries and chunk must be of size
+// multiplies by 512.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Page
+func (b *Blob) ClearRange(blobRange BlobRange, options *PutPageOptions) error {
+ return b.modifyRange(blobRange, nil, options)
+}
+
+func (b *Blob) modifyRange(blobRange BlobRange, bytes io.Reader, options *PutPageOptions) error {
+ if blobRange.End < blobRange.Start {
+ return errors.New("the value for rangeEnd must be greater than or equal to rangeStart")
+ }
+ if blobRange.Start%512 != 0 {
+ return errors.New("the value for rangeStart must be a multiple of 512")
+ }
+ if blobRange.End%512 != 511 {
+ return errors.New("the value for rangeEnd must be a multiple of 512 - 1")
+ }
+
+ params := url.Values{"comp": {"page"}}
+
+ // default to clear
+ write := "clear"
+ var cl uint64
+
+ // if bytes is not nil then this is an update operation
+ if bytes != nil {
+ write = "update"
+ cl = (blobRange.End - blobRange.Start) + 1
+ }
+
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypePage)
+ headers["x-ms-page-write"] = write
+ headers["x-ms-range"] = blobRange.String()
+ headers["Content-Length"] = fmt.Sprintf("%v", cl)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, bytes, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusCreated})
+}
+
+// GetPageRangesOptions includes the options for a get page ranges operation
+type GetPageRangesOptions struct {
+ Timeout uint
+ Snapshot *time.Time
+ PreviousSnapshot *time.Time
+ Range *BlobRange
+ LeaseID string `header:"x-ms-lease-id"`
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// GetPageRanges returns the list of valid page ranges for a page blob.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Get-Page-Ranges
+func (b *Blob) GetPageRanges(options *GetPageRangesOptions) (GetPageRangesResponse, error) {
+ params := url.Values{"comp": {"pagelist"}}
+ headers := b.Container.bsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ params = addSnapshot(params, options.Snapshot)
+ if options.PreviousSnapshot != nil {
+ params.Add("prevsnapshot", timeRFC3339Formatted(*options.PreviousSnapshot))
+ }
+ if options.Range != nil {
+ headers["Range"] = options.Range.String()
+ }
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ var out GetPageRangesResponse
+ resp, err := b.Container.bsc.client.exec(http.MethodGet, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return out, err
+ }
+ defer drainRespBody(resp)
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return out, err
+ }
+ err = xmlUnmarshal(resp.Body, &out)
+ return out, err
+}
+
+// PutPageBlob initializes an empty page blob with specified name and maximum
+// size in bytes (size must be aligned to a 512-byte boundary). A page blob must
+// be created using this method before writing pages.
+//
+// See CreateBlockBlobFromReader for more info on creating blobs.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Put-Blob
+func (b *Blob) PutPageBlob(options *PutBlobOptions) error {
+ if b.Properties.ContentLength%512 != 0 {
+ return errors.New("Content length must be aligned to a 512-byte boundary")
+ }
+
+ params := url.Values{}
+ headers := b.Container.bsc.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypePage)
+ headers["x-ms-blob-content-length"] = fmt.Sprintf("%v", b.Properties.ContentLength)
+ headers["x-ms-blob-sequence-number"] = fmt.Sprintf("%v", b.Properties.SequenceNumber)
+ headers = mergeHeaders(headers, headersFromStruct(b.Properties))
+ headers = b.Container.bsc.client.addMetadataToHeaders(headers, b.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := b.Container.bsc.client.getEndpoint(blobServiceName, b.buildPath(), params)
+
+ resp, err := b.Container.bsc.client.exec(http.MethodPut, uri, headers, nil, b.Container.bsc.auth)
+ if err != nil {
+ return err
+ }
+ return b.respondCreation(resp, BlobTypePage)
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/queue.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/queue.go
new file mode 100644
index 00000000000..f90050cb002
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/queue.go
@@ -0,0 +1,436 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/xml"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "strconv"
+ "time"
+)
+
+const (
+ // casing is per Golang's http.Header canonicalizing the header names.
+ approximateMessagesCountHeader = "X-Ms-Approximate-Messages-Count"
+)
+
+// QueueAccessPolicy represents each access policy in the queue ACL.
+type QueueAccessPolicy struct {
+ ID string
+ StartTime time.Time
+ ExpiryTime time.Time
+ CanRead bool
+ CanAdd bool
+ CanUpdate bool
+ CanProcess bool
+}
+
+// QueuePermissions represents the queue ACLs.
+type QueuePermissions struct {
+ AccessPolicies []QueueAccessPolicy
+}
+
+// SetQueuePermissionOptions includes options for a set queue permissions operation
+type SetQueuePermissionOptions struct {
+ Timeout uint
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Queue represents an Azure queue.
+type Queue struct {
+ qsc *QueueServiceClient
+ Name string
+ Metadata map[string]string
+ AproxMessageCount uint64
+}
+
+func (q *Queue) buildPath() string {
+ return fmt.Sprintf("/%s", q.Name)
+}
+
+func (q *Queue) buildPathMessages() string {
+ return fmt.Sprintf("%s/messages", q.buildPath())
+}
+
+// QueueServiceOptions includes options for some queue service operations
+type QueueServiceOptions struct {
+ Timeout uint
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// Create operation creates a queue under the given account.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Create-Queue4
+func (q *Queue) Create(options *QueueServiceOptions) error {
+ params := url.Values{}
+ headers := q.qsc.client.getStandardHeaders()
+ headers = q.qsc.client.addMetadataToHeaders(headers, q.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), params)
+
+ resp, err := q.qsc.client.exec(http.MethodPut, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusCreated})
+}
+
+// Delete operation permanently deletes the specified queue.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-Queue3
+func (q *Queue) Delete(options *QueueServiceOptions) error {
+ params := url.Values{}
+ headers := q.qsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), params)
+ resp, err := q.qsc.client.exec(http.MethodDelete, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+// Exists returns true if a queue with given name exists.
+func (q *Queue) Exists() (bool, error) {
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), url.Values{"comp": {"metadata"}})
+ resp, err := q.qsc.client.exec(http.MethodGet, uri, q.qsc.client.getStandardHeaders(), nil, q.qsc.auth)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusOK, nil
+ }
+ err = getErrorFromResponse(resp)
+ }
+ return false, err
+}
+
+// SetMetadata operation sets user-defined metadata on the specified queue.
+// Metadata is associated with the queue as name-value pairs.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-Queue-Metadata
+func (q *Queue) SetMetadata(options *QueueServiceOptions) error {
+ params := url.Values{"comp": {"metadata"}}
+ headers := q.qsc.client.getStandardHeaders()
+ headers = q.qsc.client.addMetadataToHeaders(headers, q.Metadata)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), params)
+
+ resp, err := q.qsc.client.exec(http.MethodPut, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+// GetMetadata operation retrieves user-defined metadata and queue
+// properties on the specified queue. Metadata is associated with
+// the queue as name-values pairs.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-Queue-Metadata
+//
+// Because the way Golang's http client (and http.Header in particular)
+// canonicalize header names, the returned metadata names would always
+// be all lower case.
+func (q *Queue) GetMetadata(options *QueueServiceOptions) error {
+ params := url.Values{"comp": {"metadata"}}
+ headers := q.qsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), params)
+
+ resp, err := q.qsc.client.exec(http.MethodGet, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return err
+ }
+
+ aproxMessagesStr := resp.Header.Get(http.CanonicalHeaderKey(approximateMessagesCountHeader))
+ if aproxMessagesStr != "" {
+ aproxMessages, err := strconv.ParseUint(aproxMessagesStr, 10, 64)
+ if err != nil {
+ return err
+ }
+ q.AproxMessageCount = aproxMessages
+ }
+
+ q.Metadata = getMetadataFromHeaders(resp.Header)
+ return nil
+}
+
+// GetMessageReference returns a message object with the specified text.
+func (q *Queue) GetMessageReference(text string) *Message {
+ return &Message{
+ Queue: q,
+ Text: text,
+ }
+}
+
+// GetMessagesOptions is the set of options can be specified for Get
+// Messsages operation. A zero struct does not use any preferences for the
+// request.
+type GetMessagesOptions struct {
+ Timeout uint
+ NumOfMessages int
+ VisibilityTimeout int
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+type messages struct {
+ XMLName xml.Name `xml:"QueueMessagesList"`
+ Messages []Message `xml:"QueueMessage"`
+}
+
+// GetMessages operation retrieves one or more messages from the front of the
+// queue.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Get-Messages
+func (q *Queue) GetMessages(options *GetMessagesOptions) ([]Message, error) {
+ query := url.Values{}
+ headers := q.qsc.client.getStandardHeaders()
+
+ if options != nil {
+ if options.NumOfMessages != 0 {
+ query.Set("numofmessages", strconv.Itoa(options.NumOfMessages))
+ }
+ if options.VisibilityTimeout != 0 {
+ query.Set("visibilitytimeout", strconv.Itoa(options.VisibilityTimeout))
+ }
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPathMessages(), query)
+
+ resp, err := q.qsc.client.exec(http.MethodGet, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return []Message{}, err
+ }
+ defer resp.Body.Close()
+
+ var out messages
+ err = xmlUnmarshal(resp.Body, &out)
+ if err != nil {
+ return []Message{}, err
+ }
+ for i := range out.Messages {
+ out.Messages[i].Queue = q
+ }
+ return out.Messages, err
+}
+
+// PeekMessagesOptions is the set of options can be specified for Peek
+// Messsage operation. A zero struct does not use any preferences for the
+// request.
+type PeekMessagesOptions struct {
+ Timeout uint
+ NumOfMessages int
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// PeekMessages retrieves one or more messages from the front of the queue, but
+// does not alter the visibility of the message.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Peek-Messages
+func (q *Queue) PeekMessages(options *PeekMessagesOptions) ([]Message, error) {
+ query := url.Values{"peekonly": {"true"}} // Required for peek operation
+ headers := q.qsc.client.getStandardHeaders()
+
+ if options != nil {
+ if options.NumOfMessages != 0 {
+ query.Set("numofmessages", strconv.Itoa(options.NumOfMessages))
+ }
+ query = addTimeout(query, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPathMessages(), query)
+
+ resp, err := q.qsc.client.exec(http.MethodGet, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return []Message{}, err
+ }
+ defer resp.Body.Close()
+
+ var out messages
+ err = xmlUnmarshal(resp.Body, &out)
+ if err != nil {
+ return []Message{}, err
+ }
+ for i := range out.Messages {
+ out.Messages[i].Queue = q
+ }
+ return out.Messages, err
+}
+
+// ClearMessages operation deletes all messages from the specified queue.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Clear-Messages
+func (q *Queue) ClearMessages(options *QueueServiceOptions) error {
+ params := url.Values{}
+ headers := q.qsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPathMessages(), params)
+
+ resp, err := q.qsc.client.exec(http.MethodDelete, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+// SetPermissions sets up queue permissions
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/set-queue-acl
+func (q *Queue) SetPermissions(permissions QueuePermissions, options *SetQueuePermissionOptions) error {
+ body, length, err := generateQueueACLpayload(permissions.AccessPolicies)
+ if err != nil {
+ return err
+ }
+
+ params := url.Values{
+ "comp": {"acl"},
+ }
+ headers := q.qsc.client.getStandardHeaders()
+ headers["Content-Length"] = strconv.Itoa(length)
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), params)
+ resp, err := q.qsc.client.exec(http.MethodPut, uri, headers, body, q.qsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+func generateQueueACLpayload(policies []QueueAccessPolicy) (io.Reader, int, error) {
+ sil := SignedIdentifiers{
+ SignedIdentifiers: []SignedIdentifier{},
+ }
+ for _, qapd := range policies {
+ permission := qapd.generateQueuePermissions()
+ signedIdentifier := convertAccessPolicyToXMLStructs(qapd.ID, qapd.StartTime, qapd.ExpiryTime, permission)
+ sil.SignedIdentifiers = append(sil.SignedIdentifiers, signedIdentifier)
+ }
+ return xmlMarshal(sil)
+}
+
+func (qapd *QueueAccessPolicy) generateQueuePermissions() (permissions string) {
+ // generate the permissions string (raup).
+ // still want the end user API to have bool flags.
+ permissions = ""
+
+ if qapd.CanRead {
+ permissions += "r"
+ }
+
+ if qapd.CanAdd {
+ permissions += "a"
+ }
+
+ if qapd.CanUpdate {
+ permissions += "u"
+ }
+
+ if qapd.CanProcess {
+ permissions += "p"
+ }
+
+ return permissions
+}
+
+// GetQueuePermissionOptions includes options for a get queue permissions operation
+type GetQueuePermissionOptions struct {
+ Timeout uint
+ RequestID string `header:"x-ms-client-request-id"`
+}
+
+// GetPermissions gets the queue permissions as per https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-queue-acl
+// If timeout is 0 then it will not be passed to Azure
+func (q *Queue) GetPermissions(options *GetQueuePermissionOptions) (*QueuePermissions, error) {
+ params := url.Values{
+ "comp": {"acl"},
+ }
+ headers := q.qsc.client.getStandardHeaders()
+
+ if options != nil {
+ params = addTimeout(params, options.Timeout)
+ headers = mergeHeaders(headers, headersFromStruct(*options))
+ }
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), params)
+ resp, err := q.qsc.client.exec(http.MethodGet, uri, headers, nil, q.qsc.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ var ap AccessPolicy
+ err = xmlUnmarshal(resp.Body, &ap.SignedIdentifiersList)
+ if err != nil {
+ return nil, err
+ }
+ return buildQueueAccessPolicy(ap, &resp.Header), nil
+}
+
+func buildQueueAccessPolicy(ap AccessPolicy, headers *http.Header) *QueuePermissions {
+ permissions := QueuePermissions{
+ AccessPolicies: []QueueAccessPolicy{},
+ }
+
+ for _, policy := range ap.SignedIdentifiersList.SignedIdentifiers {
+ qapd := QueueAccessPolicy{
+ ID: policy.ID,
+ StartTime: policy.AccessPolicy.StartTime,
+ ExpiryTime: policy.AccessPolicy.ExpiryTime,
+ }
+ qapd.CanRead = updatePermissions(policy.AccessPolicy.Permission, "r")
+ qapd.CanAdd = updatePermissions(policy.AccessPolicy.Permission, "a")
+ qapd.CanUpdate = updatePermissions(policy.AccessPolicy.Permission, "u")
+ qapd.CanProcess = updatePermissions(policy.AccessPolicy.Permission, "p")
+
+ permissions.AccessPolicies = append(permissions.AccessPolicies, qapd)
+ }
+ return &permissions
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/queuesasuri.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/queuesasuri.go
new file mode 100644
index 00000000000..28d9ab937e2
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/queuesasuri.go
@@ -0,0 +1,146 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "errors"
+ "fmt"
+ "net/url"
+ "strings"
+ "time"
+)
+
+// QueueSASOptions are options to construct a blob SAS
+// URI.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+type QueueSASOptions struct {
+ QueueSASPermissions
+ SASOptions
+}
+
+// QueueSASPermissions includes the available permissions for
+// a queue SAS URI.
+type QueueSASPermissions struct {
+ Read bool
+ Add bool
+ Update bool
+ Process bool
+}
+
+func (q QueueSASPermissions) buildString() string {
+ permissions := ""
+
+ if q.Read {
+ permissions += "r"
+ }
+ if q.Add {
+ permissions += "a"
+ }
+ if q.Update {
+ permissions += "u"
+ }
+ if q.Process {
+ permissions += "p"
+ }
+ return permissions
+}
+
+// GetSASURI creates an URL to the specified queue which contains the Shared
+// Access Signature with specified permissions and expiration time.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+func (q *Queue) GetSASURI(options QueueSASOptions) (string, error) {
+ canonicalizedResource, err := q.qsc.client.buildCanonicalizedResource(q.buildPath(), q.qsc.auth, true)
+ if err != nil {
+ return "", err
+ }
+
+ // "The canonicalizedresouce portion of the string is a canonical path to the signed resource.
+ // It must include the service name (blob, table, queue or file) for version 2015-02-21 or
+ // later, the storage account name, and the resource name, and must be URL-decoded.
+ // -- https://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
+ // We need to replace + with %2b first to avoid being treated as a space (which is correct for query strings, but not the path component).
+ canonicalizedResource = strings.Replace(canonicalizedResource, "+", "%2b", -1)
+ canonicalizedResource, err = url.QueryUnescape(canonicalizedResource)
+ if err != nil {
+ return "", err
+ }
+
+ signedStart := ""
+ if options.Start != (time.Time{}) {
+ signedStart = options.Start.UTC().Format(time.RFC3339)
+ }
+ signedExpiry := options.Expiry.UTC().Format(time.RFC3339)
+
+ protocols := "https,http"
+ if options.UseHTTPS {
+ protocols = "https"
+ }
+
+ permissions := options.QueueSASPermissions.buildString()
+ stringToSign, err := queueSASStringToSign(q.qsc.client.apiVersion, canonicalizedResource, signedStart, signedExpiry, options.IP, permissions, protocols, options.Identifier)
+ if err != nil {
+ return "", err
+ }
+
+ sig := q.qsc.client.computeHmac256(stringToSign)
+ sasParams := url.Values{
+ "sv": {q.qsc.client.apiVersion},
+ "se": {signedExpiry},
+ "sp": {permissions},
+ "sig": {sig},
+ }
+
+ if q.qsc.client.apiVersion >= "2015-04-05" {
+ sasParams.Add("spr", protocols)
+ addQueryParameter(sasParams, "sip", options.IP)
+ }
+
+ uri := q.qsc.client.getEndpoint(queueServiceName, q.buildPath(), nil)
+ sasURL, err := url.Parse(uri)
+ if err != nil {
+ return "", err
+ }
+ sasURL.RawQuery = sasParams.Encode()
+ return sasURL.String(), nil
+}
+
+func queueSASStringToSign(signedVersion, canonicalizedResource, signedStart, signedExpiry, signedIP, signedPermissions, protocols, signedIdentifier string) (string, error) {
+
+ if signedVersion >= "2015-02-21" {
+ canonicalizedResource = "/queue" + canonicalizedResource
+ }
+
+ // https://msdn.microsoft.com/en-us/library/azure/dn140255.aspx#Anchor_12
+ if signedVersion >= "2015-04-05" {
+ return fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s",
+ signedPermissions,
+ signedStart,
+ signedExpiry,
+ canonicalizedResource,
+ signedIdentifier,
+ signedIP,
+ protocols,
+ signedVersion), nil
+
+ }
+
+ // reference: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
+ if signedVersion >= "2013-08-15" {
+ return fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s", signedPermissions, signedStart, signedExpiry, canonicalizedResource, signedIdentifier, signedVersion), nil
+ }
+
+ return "", errors.New("storage: not implemented SAS for versions earlier than 2013-08-15")
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/queueserviceclient.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/queueserviceclient.go
new file mode 100644
index 00000000000..29febe146f6
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/queueserviceclient.go
@@ -0,0 +1,42 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// QueueServiceClient contains operations for Microsoft Azure Queue Storage
+// Service.
+type QueueServiceClient struct {
+ client Client
+ auth authentication
+}
+
+// GetServiceProperties gets the properties of your storage account's queue service.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-queue-service-properties
+func (q *QueueServiceClient) GetServiceProperties() (*ServiceProperties, error) {
+ return q.client.getServiceProperties(queueServiceName, q.auth)
+}
+
+// SetServiceProperties sets the properties of your storage account's queue service.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/set-queue-service-properties
+func (q *QueueServiceClient) SetServiceProperties(props ServiceProperties) error {
+ return q.client.setServiceProperties(props, queueServiceName, q.auth)
+}
+
+// GetQueueReference returns a Container object for the specified queue name.
+func (q *QueueServiceClient) GetQueueReference(name string) *Queue {
+ return &Queue{
+ qsc: q,
+ Name: name,
+ }
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/share.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/share.go
new file mode 100644
index 00000000000..cf75a265915
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/share.go
@@ -0,0 +1,216 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+)
+
+// Share represents an Azure file share.
+type Share struct {
+ fsc *FileServiceClient
+ Name string `xml:"Name"`
+ Properties ShareProperties `xml:"Properties"`
+ Metadata map[string]string
+}
+
+// ShareProperties contains various properties of a share.
+type ShareProperties struct {
+ LastModified string `xml:"Last-Modified"`
+ Etag string `xml:"Etag"`
+ Quota int `xml:"Quota"`
+}
+
+// builds the complete path for this share object.
+func (s *Share) buildPath() string {
+ return fmt.Sprintf("/%s", s.Name)
+}
+
+// Create this share under the associated account.
+// If a share with the same name already exists, the operation fails.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Create-Share
+func (s *Share) Create(options *FileRequestOptions) error {
+ extraheaders := map[string]string{}
+ if s.Properties.Quota > 0 {
+ extraheaders["x-ms-share-quota"] = strconv.Itoa(s.Properties.Quota)
+ }
+
+ params := prepareOptions(options)
+ headers, err := s.fsc.createResource(s.buildPath(), resourceShare, params, mergeMDIntoExtraHeaders(s.Metadata, extraheaders), []int{http.StatusCreated})
+ if err != nil {
+ return err
+ }
+
+ s.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// CreateIfNotExists creates this share under the associated account if
+// it does not exist. Returns true if the share is newly created or false if
+// the share already exists.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Create-Share
+func (s *Share) CreateIfNotExists(options *FileRequestOptions) (bool, error) {
+ extraheaders := map[string]string{}
+ if s.Properties.Quota > 0 {
+ extraheaders["x-ms-share-quota"] = strconv.Itoa(s.Properties.Quota)
+ }
+
+ params := prepareOptions(options)
+ resp, err := s.fsc.createResourceNoClose(s.buildPath(), resourceShare, params, extraheaders)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusCreated || resp.StatusCode == http.StatusConflict {
+ if resp.StatusCode == http.StatusCreated {
+ s.updateEtagAndLastModified(resp.Header)
+ return true, nil
+ }
+ return false, s.FetchAttributes(nil)
+ }
+ }
+
+ return false, err
+}
+
+// Delete marks this share for deletion. The share along with any files
+// and directories contained within it are later deleted during garbage
+// collection. If the share does not exist the operation fails
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-Share
+func (s *Share) Delete(options *FileRequestOptions) error {
+ return s.fsc.deleteResource(s.buildPath(), resourceShare, options)
+}
+
+// DeleteIfExists operation marks this share for deletion if it exists.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Delete-Share
+func (s *Share) DeleteIfExists(options *FileRequestOptions) (bool, error) {
+ resp, err := s.fsc.deleteResourceNoClose(s.buildPath(), resourceShare, options)
+ if resp != nil {
+ defer drainRespBody(resp)
+ if resp.StatusCode == http.StatusAccepted || resp.StatusCode == http.StatusNotFound {
+ return resp.StatusCode == http.StatusAccepted, nil
+ }
+ }
+ return false, err
+}
+
+// Exists returns true if this share already exists
+// on the storage account, otherwise returns false.
+func (s *Share) Exists() (bool, error) {
+ exists, headers, err := s.fsc.resourceExists(s.buildPath(), resourceShare)
+ if exists {
+ s.updateEtagAndLastModified(headers)
+ s.updateQuota(headers)
+ }
+ return exists, err
+}
+
+// FetchAttributes retrieves metadata and properties for this share.
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-share-properties
+func (s *Share) FetchAttributes(options *FileRequestOptions) error {
+ params := prepareOptions(options)
+ headers, err := s.fsc.getResourceHeaders(s.buildPath(), compNone, resourceShare, params, http.MethodHead)
+ if err != nil {
+ return err
+ }
+
+ s.updateEtagAndLastModified(headers)
+ s.updateQuota(headers)
+ s.Metadata = getMetadataFromHeaders(headers)
+
+ return nil
+}
+
+// GetRootDirectoryReference returns a Directory object at the root of this share.
+func (s *Share) GetRootDirectoryReference() *Directory {
+ return &Directory{
+ fsc: s.fsc,
+ share: s,
+ }
+}
+
+// ServiceClient returns the FileServiceClient associated with this share.
+func (s *Share) ServiceClient() *FileServiceClient {
+ return s.fsc
+}
+
+// SetMetadata replaces the metadata for this share.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetShareMetadata. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/set-share-metadata
+func (s *Share) SetMetadata(options *FileRequestOptions) error {
+ headers, err := s.fsc.setResourceHeaders(s.buildPath(), compMetadata, resourceShare, mergeMDIntoExtraHeaders(s.Metadata, nil), options)
+ if err != nil {
+ return err
+ }
+
+ s.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// SetProperties sets system properties for this share.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by SetShareProperties. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/Set-Share-Properties
+func (s *Share) SetProperties(options *FileRequestOptions) error {
+ extraheaders := map[string]string{}
+ if s.Properties.Quota > 0 {
+ if s.Properties.Quota > 5120 {
+ return fmt.Errorf("invalid value %v for quota, valid values are [1, 5120]", s.Properties.Quota)
+ }
+ extraheaders["x-ms-share-quota"] = strconv.Itoa(s.Properties.Quota)
+ }
+
+ headers, err := s.fsc.setResourceHeaders(s.buildPath(), compProperties, resourceShare, extraheaders, options)
+ if err != nil {
+ return err
+ }
+
+ s.updateEtagAndLastModified(headers)
+ return nil
+}
+
+// updates Etag and last modified date
+func (s *Share) updateEtagAndLastModified(headers http.Header) {
+ s.Properties.Etag = headers.Get("Etag")
+ s.Properties.LastModified = headers.Get("Last-Modified")
+}
+
+// updates quota value
+func (s *Share) updateQuota(headers http.Header) {
+ quota, err := strconv.Atoi(headers.Get("x-ms-share-quota"))
+ if err == nil {
+ s.Properties.Quota = quota
+ }
+}
+
+// URL gets the canonical URL to this share. This method does not create a publicly accessible
+// URL if the share is private and this method does not check if the share exists.
+func (s *Share) URL() string {
+ return s.fsc.client.getEndpoint(fileServiceName, s.buildPath(), url.Values{})
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/storagepolicy.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/storagepolicy.go
new file mode 100644
index 00000000000..056ab398a81
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/storagepolicy.go
@@ -0,0 +1,61 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "strings"
+ "time"
+)
+
+// AccessPolicyDetailsXML has specifics about an access policy
+// annotated with XML details.
+type AccessPolicyDetailsXML struct {
+ StartTime time.Time `xml:"Start"`
+ ExpiryTime time.Time `xml:"Expiry"`
+ Permission string `xml:"Permission"`
+}
+
+// SignedIdentifier is a wrapper for a specific policy
+type SignedIdentifier struct {
+ ID string `xml:"Id"`
+ AccessPolicy AccessPolicyDetailsXML `xml:"AccessPolicy"`
+}
+
+// SignedIdentifiers part of the response from GetPermissions call.
+type SignedIdentifiers struct {
+ SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"`
+}
+
+// AccessPolicy is the response type from the GetPermissions call.
+type AccessPolicy struct {
+ SignedIdentifiersList SignedIdentifiers `xml:"SignedIdentifiers"`
+}
+
+// convertAccessPolicyToXMLStructs converts between AccessPolicyDetails which is a struct better for API usage to the
+// AccessPolicy struct which will get converted to XML.
+func convertAccessPolicyToXMLStructs(id string, startTime time.Time, expiryTime time.Time, permissions string) SignedIdentifier {
+ return SignedIdentifier{
+ ID: id,
+ AccessPolicy: AccessPolicyDetailsXML{
+ StartTime: startTime.UTC().Round(time.Second),
+ ExpiryTime: expiryTime.UTC().Round(time.Second),
+ Permission: permissions,
+ },
+ }
+}
+
+func updatePermissions(permissions, permission string) bool {
+ return strings.Contains(permissions, permission)
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/storageservice.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/storageservice.go
new file mode 100644
index 00000000000..dc41992227c
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/storageservice.go
@@ -0,0 +1,150 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "net/http"
+ "net/url"
+ "strconv"
+)
+
+// ServiceProperties represents the storage account service properties
+type ServiceProperties struct {
+ Logging *Logging
+ HourMetrics *Metrics
+ MinuteMetrics *Metrics
+ Cors *Cors
+ DeleteRetentionPolicy *RetentionPolicy // blob storage only
+ StaticWebsite *StaticWebsite // blob storage only
+}
+
+// Logging represents the Azure Analytics Logging settings
+type Logging struct {
+ Version string
+ Delete bool
+ Read bool
+ Write bool
+ RetentionPolicy *RetentionPolicy
+}
+
+// RetentionPolicy indicates if retention is enabled and for how many days
+type RetentionPolicy struct {
+ Enabled bool
+ Days *int
+}
+
+// Metrics provide request statistics.
+type Metrics struct {
+ Version string
+ Enabled bool
+ IncludeAPIs *bool
+ RetentionPolicy *RetentionPolicy
+}
+
+// Cors includes all the CORS rules
+type Cors struct {
+ CorsRule []CorsRule
+}
+
+// CorsRule includes all settings for a Cors rule
+type CorsRule struct {
+ AllowedOrigins string
+ AllowedMethods string
+ MaxAgeInSeconds int
+ ExposedHeaders string
+ AllowedHeaders string
+}
+
+// StaticWebsite - The properties that enable an account to host a static website
+type StaticWebsite struct {
+ // Enabled - Indicates whether this account is hosting a static website
+ Enabled bool
+ // IndexDocument - The default name of the index page under each directory
+ IndexDocument *string
+ // ErrorDocument404Path - The absolute path of the custom 404 page
+ ErrorDocument404Path *string
+}
+
+func (c Client) getServiceProperties(service string, auth authentication) (*ServiceProperties, error) {
+ query := url.Values{
+ "restype": {"service"},
+ "comp": {"properties"},
+ }
+ uri := c.getEndpoint(service, "", query)
+ headers := c.getStandardHeaders()
+
+ resp, err := c.exec(http.MethodGet, uri, headers, nil, auth)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ var out ServiceProperties
+ err = xmlUnmarshal(resp.Body, &out)
+ if err != nil {
+ return nil, err
+ }
+
+ return &out, nil
+}
+
+func (c Client) setServiceProperties(props ServiceProperties, service string, auth authentication) error {
+ query := url.Values{
+ "restype": {"service"},
+ "comp": {"properties"},
+ }
+ uri := c.getEndpoint(service, "", query)
+
+ // Ideally, StorageServiceProperties would be the output struct
+ // This is to avoid golint stuttering, while generating the correct XML
+ type StorageServiceProperties struct {
+ Logging *Logging
+ HourMetrics *Metrics
+ MinuteMetrics *Metrics
+ Cors *Cors
+ DeleteRetentionPolicy *RetentionPolicy
+ StaticWebsite *StaticWebsite
+ }
+ input := StorageServiceProperties{
+ Logging: props.Logging,
+ HourMetrics: props.HourMetrics,
+ MinuteMetrics: props.MinuteMetrics,
+ Cors: props.Cors,
+ }
+ // only set these fields for blob storage else it's invalid XML
+ if service == blobServiceName {
+ input.DeleteRetentionPolicy = props.DeleteRetentionPolicy
+ input.StaticWebsite = props.StaticWebsite
+ }
+
+ body, length, err := xmlMarshal(input)
+ if err != nil {
+ return err
+ }
+
+ headers := c.getStandardHeaders()
+ headers["Content-Length"] = strconv.Itoa(length)
+
+ resp, err := c.exec(http.MethodPut, uri, headers, body, auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+ return checkRespCode(resp, []int{http.StatusAccepted})
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/table.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/table.go
new file mode 100644
index 00000000000..0febf077f6b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/table.go
@@ -0,0 +1,423 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+)
+
+const (
+ tablesURIPath = "/Tables"
+ nextTableQueryParameter = "NextTableName"
+ headerNextPartitionKey = "x-ms-continuation-NextPartitionKey"
+ headerNextRowKey = "x-ms-continuation-NextRowKey"
+ nextPartitionKeyQueryParameter = "NextPartitionKey"
+ nextRowKeyQueryParameter = "NextRowKey"
+)
+
+// TableAccessPolicy are used for SETTING table policies
+type TableAccessPolicy struct {
+ ID string
+ StartTime time.Time
+ ExpiryTime time.Time
+ CanRead bool
+ CanAppend bool
+ CanUpdate bool
+ CanDelete bool
+}
+
+// Table represents an Azure table.
+type Table struct {
+ tsc *TableServiceClient
+ Name string `json:"TableName"`
+ OdataEditLink string `json:"odata.editLink"`
+ OdataID string `json:"odata.id"`
+ OdataMetadata string `json:"odata.metadata"`
+ OdataType string `json:"odata.type"`
+}
+
+// EntityQueryResult contains the response from
+// ExecuteQuery and ExecuteQueryNextResults functions.
+type EntityQueryResult struct {
+ OdataMetadata string `json:"odata.metadata"`
+ Entities []*Entity `json:"value"`
+ QueryNextLink
+ table *Table
+}
+
+type continuationToken struct {
+ NextPartitionKey string
+ NextRowKey string
+}
+
+func (t *Table) buildPath() string {
+ return fmt.Sprintf("/%s", t.Name)
+}
+
+func (t *Table) buildSpecificPath() string {
+ return fmt.Sprintf("%s('%s')", tablesURIPath, t.Name)
+}
+
+// Get gets the referenced table.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/querying-tables-and-entities
+func (t *Table) Get(timeout uint, ml MetadataLevel) error {
+ if ml == EmptyPayload {
+ return errEmptyPayload
+ }
+
+ query := url.Values{
+ "timeout": {strconv.FormatUint(uint64(timeout), 10)},
+ }
+ headers := t.tsc.client.getStandardHeaders()
+ headers[headerAccept] = string(ml)
+
+ uri := t.tsc.client.getEndpoint(tableServiceName, t.buildSpecificPath(), query)
+ resp, err := t.tsc.client.exec(http.MethodGet, uri, headers, nil, t.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return err
+ }
+
+ respBody, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+ err = json.Unmarshal(respBody, t)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// Create creates the referenced table.
+// This function fails if the name is not compliant
+// with the specification or the tables already exists.
+// ml determines the level of detail of metadata in the operation response,
+// or no data at all.
+// See https://docs.microsoft.com/rest/api/storageservices/fileservices/create-table
+func (t *Table) Create(timeout uint, ml MetadataLevel, options *TableOptions) error {
+ uri := t.tsc.client.getEndpoint(tableServiceName, tablesURIPath, url.Values{
+ "timeout": {strconv.FormatUint(uint64(timeout), 10)},
+ })
+
+ type createTableRequest struct {
+ TableName string `json:"TableName"`
+ }
+ req := createTableRequest{TableName: t.Name}
+ buf := new(bytes.Buffer)
+ if err := json.NewEncoder(buf).Encode(req); err != nil {
+ return err
+ }
+
+ headers := t.tsc.client.getStandardHeaders()
+ headers = addReturnContentHeaders(headers, ml)
+ headers = addBodyRelatedHeaders(headers, buf.Len())
+ headers = options.addToHeaders(headers)
+
+ resp, err := t.tsc.client.exec(http.MethodPost, uri, headers, buf, t.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+
+ if ml == EmptyPayload {
+ if err := checkRespCode(resp, []int{http.StatusNoContent}); err != nil {
+ return err
+ }
+ } else {
+ if err := checkRespCode(resp, []int{http.StatusCreated}); err != nil {
+ return err
+ }
+ }
+
+ if ml != EmptyPayload {
+ data, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return err
+ }
+ err = json.Unmarshal(data, t)
+ if err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// Delete deletes the referenced table.
+// This function fails if the table is not present.
+// Be advised: Delete deletes all the entries that may be present.
+// See https://docs.microsoft.com/rest/api/storageservices/fileservices/delete-table
+func (t *Table) Delete(timeout uint, options *TableOptions) error {
+ uri := t.tsc.client.getEndpoint(tableServiceName, t.buildSpecificPath(), url.Values{
+ "timeout": {strconv.Itoa(int(timeout))},
+ })
+
+ headers := t.tsc.client.getStandardHeaders()
+ headers = addReturnContentHeaders(headers, EmptyPayload)
+ headers = options.addToHeaders(headers)
+
+ resp, err := t.tsc.client.exec(http.MethodDelete, uri, headers, nil, t.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+// QueryOptions includes options for a query entities operation.
+// Top, filter and select are OData query options.
+type QueryOptions struct {
+ Top uint
+ Filter string
+ Select []string
+ RequestID string
+}
+
+func (options *QueryOptions) getParameters() (url.Values, map[string]string) {
+ query := url.Values{}
+ headers := map[string]string{}
+ if options != nil {
+ if options.Top > 0 {
+ query.Add(OdataTop, strconv.FormatUint(uint64(options.Top), 10))
+ }
+ if options.Filter != "" {
+ query.Add(OdataFilter, options.Filter)
+ }
+ if len(options.Select) > 0 {
+ query.Add(OdataSelect, strings.Join(options.Select, ","))
+ }
+ headers = addToHeaders(headers, "x-ms-client-request-id", options.RequestID)
+ }
+ return query, headers
+}
+
+// QueryEntities returns the entities in the table.
+// You can use query options defined by the OData Protocol specification.
+//
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/query-entities
+func (t *Table) QueryEntities(timeout uint, ml MetadataLevel, options *QueryOptions) (*EntityQueryResult, error) {
+ if ml == EmptyPayload {
+ return nil, errEmptyPayload
+ }
+ query, headers := options.getParameters()
+ query = addTimeout(query, timeout)
+ uri := t.tsc.client.getEndpoint(tableServiceName, t.buildPath(), query)
+ return t.queryEntities(uri, headers, ml)
+}
+
+// NextResults returns the next page of results
+// from a QueryEntities or NextResults operation.
+//
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/query-entities
+// See https://docs.microsoft.com/rest/api/storageservices/fileservices/query-timeout-and-pagination
+func (eqr *EntityQueryResult) NextResults(options *TableOptions) (*EntityQueryResult, error) {
+ if eqr == nil {
+ return nil, errNilPreviousResult
+ }
+ if eqr.NextLink == nil {
+ return nil, errNilNextLink
+ }
+ headers := options.addToHeaders(map[string]string{})
+ return eqr.table.queryEntities(*eqr.NextLink, headers, eqr.ml)
+}
+
+// SetPermissions sets up table ACL permissions
+// See https://docs.microsoft.com/rest/api/storageservices/fileservices/Set-Table-ACL
+func (t *Table) SetPermissions(tap []TableAccessPolicy, timeout uint, options *TableOptions) error {
+ params := url.Values{"comp": {"acl"},
+ "timeout": {strconv.Itoa(int(timeout))},
+ }
+
+ uri := t.tsc.client.getEndpoint(tableServiceName, t.Name, params)
+ headers := t.tsc.client.getStandardHeaders()
+ headers = options.addToHeaders(headers)
+
+ body, length, err := generateTableACLPayload(tap)
+ if err != nil {
+ return err
+ }
+ headers["Content-Length"] = strconv.Itoa(length)
+
+ resp, err := t.tsc.client.exec(http.MethodPut, uri, headers, body, t.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp)
+
+ return checkRespCode(resp, []int{http.StatusNoContent})
+}
+
+func generateTableACLPayload(policies []TableAccessPolicy) (io.Reader, int, error) {
+ sil := SignedIdentifiers{
+ SignedIdentifiers: []SignedIdentifier{},
+ }
+ for _, tap := range policies {
+ permission := generateTablePermissions(&tap)
+ signedIdentifier := convertAccessPolicyToXMLStructs(tap.ID, tap.StartTime, tap.ExpiryTime, permission)
+ sil.SignedIdentifiers = append(sil.SignedIdentifiers, signedIdentifier)
+ }
+ return xmlMarshal(sil)
+}
+
+// GetPermissions gets the table ACL permissions
+// See https://docs.microsoft.com/rest/api/storageservices/fileservices/get-table-acl
+func (t *Table) GetPermissions(timeout int, options *TableOptions) ([]TableAccessPolicy, error) {
+ params := url.Values{"comp": {"acl"},
+ "timeout": {strconv.Itoa(int(timeout))},
+ }
+
+ uri := t.tsc.client.getEndpoint(tableServiceName, t.Name, params)
+ headers := t.tsc.client.getStandardHeaders()
+ headers = options.addToHeaders(headers)
+
+ resp, err := t.tsc.client.exec(http.MethodGet, uri, headers, nil, t.tsc.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ var ap AccessPolicy
+ err = xmlUnmarshal(resp.Body, &ap.SignedIdentifiersList)
+ if err != nil {
+ return nil, err
+ }
+ return updateTableAccessPolicy(ap), nil
+}
+
+func (t *Table) queryEntities(uri string, headers map[string]string, ml MetadataLevel) (*EntityQueryResult, error) {
+ headers = mergeHeaders(headers, t.tsc.client.getStandardHeaders())
+ if ml != EmptyPayload {
+ headers[headerAccept] = string(ml)
+ }
+
+ resp, err := t.tsc.client.exec(http.MethodGet, uri, headers, nil, t.tsc.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if err = checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ data, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+ var entities EntityQueryResult
+ err = json.Unmarshal(data, &entities)
+ if err != nil {
+ return nil, err
+ }
+
+ for i := range entities.Entities {
+ entities.Entities[i].Table = t
+ }
+ entities.table = t
+
+ contToken := extractContinuationTokenFromHeaders(resp.Header)
+ if contToken == nil {
+ entities.NextLink = nil
+ } else {
+ originalURI, err := url.Parse(uri)
+ if err != nil {
+ return nil, err
+ }
+ v := originalURI.Query()
+ if contToken.NextPartitionKey != "" {
+ v.Set(nextPartitionKeyQueryParameter, contToken.NextPartitionKey)
+ }
+ if contToken.NextRowKey != "" {
+ v.Set(nextRowKeyQueryParameter, contToken.NextRowKey)
+ }
+ newURI := t.tsc.client.getEndpoint(tableServiceName, t.buildPath(), v)
+ entities.NextLink = &newURI
+ entities.ml = ml
+ }
+
+ return &entities, nil
+}
+
+func extractContinuationTokenFromHeaders(h http.Header) *continuationToken {
+ ct := continuationToken{
+ NextPartitionKey: h.Get(headerNextPartitionKey),
+ NextRowKey: h.Get(headerNextRowKey),
+ }
+
+ if ct.NextPartitionKey != "" || ct.NextRowKey != "" {
+ return &ct
+ }
+ return nil
+}
+
+func updateTableAccessPolicy(ap AccessPolicy) []TableAccessPolicy {
+ taps := []TableAccessPolicy{}
+ for _, policy := range ap.SignedIdentifiersList.SignedIdentifiers {
+ tap := TableAccessPolicy{
+ ID: policy.ID,
+ StartTime: policy.AccessPolicy.StartTime,
+ ExpiryTime: policy.AccessPolicy.ExpiryTime,
+ }
+ tap.CanRead = updatePermissions(policy.AccessPolicy.Permission, "r")
+ tap.CanAppend = updatePermissions(policy.AccessPolicy.Permission, "a")
+ tap.CanUpdate = updatePermissions(policy.AccessPolicy.Permission, "u")
+ tap.CanDelete = updatePermissions(policy.AccessPolicy.Permission, "d")
+
+ taps = append(taps, tap)
+ }
+ return taps
+}
+
+func generateTablePermissions(tap *TableAccessPolicy) (permissions string) {
+ // generate the permissions string (raud).
+ // still want the end user API to have bool flags.
+ permissions = ""
+
+ if tap.CanRead {
+ permissions += "r"
+ }
+
+ if tap.CanAppend {
+ permissions += "a"
+ }
+
+ if tap.CanUpdate {
+ permissions += "u"
+ }
+
+ if tap.CanDelete {
+ permissions += "d"
+ }
+ return permissions
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/table_batch.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/table_batch.go
new file mode 100644
index 00000000000..5b05e3e2afa
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/table_batch.go
@@ -0,0 +1,325 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "mime/multipart"
+ "net/http"
+ "net/textproto"
+ "sort"
+ "strings"
+)
+
+// Operation type. Insert, Delete, Replace etc.
+type Operation int
+
+// consts for batch operations.
+const (
+ InsertOp = Operation(1)
+ DeleteOp = Operation(2)
+ ReplaceOp = Operation(3)
+ MergeOp = Operation(4)
+ InsertOrReplaceOp = Operation(5)
+ InsertOrMergeOp = Operation(6)
+)
+
+// BatchEntity used for tracking Entities to operate on and
+// whether operations (replace/merge etc) should be forced.
+// Wrapper for regular Entity with additional data specific for the entity.
+type BatchEntity struct {
+ *Entity
+ Force bool
+ Op Operation
+}
+
+// TableBatch stores all the entities that will be operated on during a batch process.
+// Entities can be inserted, replaced or deleted.
+type TableBatch struct {
+ BatchEntitySlice []BatchEntity
+
+ // reference to table we're operating on.
+ Table *Table
+}
+
+// defaultChangesetHeaders for changeSets
+var defaultChangesetHeaders = map[string]string{
+ "Accept": "application/json;odata=minimalmetadata",
+ "Content-Type": "application/json",
+ "Prefer": "return-no-content",
+}
+
+// NewBatch return new TableBatch for populating.
+func (t *Table) NewBatch() *TableBatch {
+ return &TableBatch{
+ Table: t,
+ }
+}
+
+// InsertEntity adds an entity in preparation for a batch insert.
+func (t *TableBatch) InsertEntity(entity *Entity) {
+ be := BatchEntity{Entity: entity, Force: false, Op: InsertOp}
+ t.BatchEntitySlice = append(t.BatchEntitySlice, be)
+}
+
+// InsertOrReplaceEntity adds an entity in preparation for a batch insert or replace.
+func (t *TableBatch) InsertOrReplaceEntity(entity *Entity, force bool) {
+ be := BatchEntity{Entity: entity, Force: false, Op: InsertOrReplaceOp}
+ t.BatchEntitySlice = append(t.BatchEntitySlice, be)
+}
+
+// InsertOrReplaceEntityByForce adds an entity in preparation for a batch insert or replace. Forces regardless of ETag
+func (t *TableBatch) InsertOrReplaceEntityByForce(entity *Entity) {
+ t.InsertOrReplaceEntity(entity, true)
+}
+
+// InsertOrMergeEntity adds an entity in preparation for a batch insert or merge.
+func (t *TableBatch) InsertOrMergeEntity(entity *Entity, force bool) {
+ be := BatchEntity{Entity: entity, Force: false, Op: InsertOrMergeOp}
+ t.BatchEntitySlice = append(t.BatchEntitySlice, be)
+}
+
+// InsertOrMergeEntityByForce adds an entity in preparation for a batch insert or merge. Forces regardless of ETag
+func (t *TableBatch) InsertOrMergeEntityByForce(entity *Entity) {
+ t.InsertOrMergeEntity(entity, true)
+}
+
+// ReplaceEntity adds an entity in preparation for a batch replace.
+func (t *TableBatch) ReplaceEntity(entity *Entity) {
+ be := BatchEntity{Entity: entity, Force: false, Op: ReplaceOp}
+ t.BatchEntitySlice = append(t.BatchEntitySlice, be)
+}
+
+// DeleteEntity adds an entity in preparation for a batch delete
+func (t *TableBatch) DeleteEntity(entity *Entity, force bool) {
+ be := BatchEntity{Entity: entity, Force: false, Op: DeleteOp}
+ t.BatchEntitySlice = append(t.BatchEntitySlice, be)
+}
+
+// DeleteEntityByForce adds an entity in preparation for a batch delete. Forces regardless of ETag
+func (t *TableBatch) DeleteEntityByForce(entity *Entity, force bool) {
+ t.DeleteEntity(entity, true)
+}
+
+// MergeEntity adds an entity in preparation for a batch merge
+func (t *TableBatch) MergeEntity(entity *Entity) {
+ be := BatchEntity{Entity: entity, Force: false, Op: MergeOp}
+ t.BatchEntitySlice = append(t.BatchEntitySlice, be)
+}
+
+// ExecuteBatch executes many table operations in one request to Azure.
+// The operations can be combinations of Insert, Delete, Replace and Merge
+// Creates the inner changeset body (various operations, Insert, Delete etc) then creates the outer request packet that encompasses
+// the changesets.
+// As per document https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/performing-entity-group-transactions
+func (t *TableBatch) ExecuteBatch() error {
+
+ id, err := newUUID()
+ if err != nil {
+ return err
+ }
+
+ changesetBoundary := fmt.Sprintf("changeset_%s", id.String())
+ uri := t.Table.tsc.client.getEndpoint(tableServiceName, "$batch", nil)
+ changesetBody, err := t.generateChangesetBody(changesetBoundary)
+ if err != nil {
+ return err
+ }
+
+ id, err = newUUID()
+ if err != nil {
+ return err
+ }
+
+ boundary := fmt.Sprintf("batch_%s", id.String())
+ body, err := generateBody(changesetBody, changesetBoundary, boundary)
+ if err != nil {
+ return err
+ }
+
+ headers := t.Table.tsc.client.getStandardHeaders()
+ headers[headerContentType] = fmt.Sprintf("multipart/mixed; boundary=%s", boundary)
+
+ resp, err := t.Table.tsc.client.execBatchOperationJSON(http.MethodPost, uri, headers, bytes.NewReader(body.Bytes()), t.Table.tsc.auth)
+ if err != nil {
+ return err
+ }
+ defer drainRespBody(resp.resp)
+
+ if err = checkRespCode(resp.resp, []int{http.StatusAccepted}); err != nil {
+
+ // check which batch failed.
+ operationFailedMessage := t.getFailedOperation(resp.odata.Err.Message.Value)
+ requestID, date, version := getDebugHeaders(resp.resp.Header)
+ return AzureStorageServiceError{
+ StatusCode: resp.resp.StatusCode,
+ Code: resp.odata.Err.Code,
+ RequestID: requestID,
+ Date: date,
+ APIVersion: version,
+ Message: operationFailedMessage,
+ }
+ }
+
+ return nil
+}
+
+// getFailedOperation parses the original Azure error string and determines which operation failed
+// and generates appropriate message.
+func (t *TableBatch) getFailedOperation(errorMessage string) string {
+ // errorMessage consists of "number:string" we just need the number.
+ sp := strings.Split(errorMessage, ":")
+ if len(sp) > 1 {
+ msg := fmt.Sprintf("Element %s in the batch returned an unexpected response code.\n%s", sp[0], errorMessage)
+ return msg
+ }
+
+ // cant parse the message, just return the original message to client
+ return errorMessage
+}
+
+// generateBody generates the complete body for the batch request.
+func generateBody(changeSetBody *bytes.Buffer, changesetBoundary string, boundary string) (*bytes.Buffer, error) {
+
+ body := new(bytes.Buffer)
+ writer := multipart.NewWriter(body)
+ writer.SetBoundary(boundary)
+ h := make(textproto.MIMEHeader)
+ h.Set(headerContentType, fmt.Sprintf("multipart/mixed; boundary=%s\r\n", changesetBoundary))
+ batchWriter, err := writer.CreatePart(h)
+ if err != nil {
+ return nil, err
+ }
+ batchWriter.Write(changeSetBody.Bytes())
+ writer.Close()
+ return body, nil
+}
+
+// generateChangesetBody generates the individual changesets for the various operations within the batch request.
+// There is a changeset for Insert, Delete, Merge etc.
+func (t *TableBatch) generateChangesetBody(changesetBoundary string) (*bytes.Buffer, error) {
+
+ body := new(bytes.Buffer)
+ writer := multipart.NewWriter(body)
+ writer.SetBoundary(changesetBoundary)
+
+ for _, be := range t.BatchEntitySlice {
+ t.generateEntitySubset(&be, writer)
+ }
+
+ writer.Close()
+ return body, nil
+}
+
+// generateVerb generates the HTTP request VERB required for each changeset.
+func generateVerb(op Operation) (string, error) {
+ switch op {
+ case InsertOp:
+ return http.MethodPost, nil
+ case DeleteOp:
+ return http.MethodDelete, nil
+ case ReplaceOp, InsertOrReplaceOp:
+ return http.MethodPut, nil
+ case MergeOp, InsertOrMergeOp:
+ return "MERGE", nil
+ default:
+ return "", errors.New("Unable to detect operation")
+ }
+}
+
+// generateQueryPath generates the query path for within the changesets
+// For inserts it will just be a table query path (table name)
+// but for other operations (modifying an existing entity) then
+// the partition/row keys need to be generated.
+func (t *TableBatch) generateQueryPath(op Operation, entity *Entity) string {
+ if op == InsertOp {
+ return entity.Table.buildPath()
+ }
+ return entity.buildPath()
+}
+
+// generateGenericOperationHeaders generates common headers for a given operation.
+func generateGenericOperationHeaders(be *BatchEntity) map[string]string {
+ retval := map[string]string{}
+
+ for k, v := range defaultChangesetHeaders {
+ retval[k] = v
+ }
+
+ if be.Op == DeleteOp || be.Op == ReplaceOp || be.Op == MergeOp {
+ if be.Force || be.Entity.OdataEtag == "" {
+ retval["If-Match"] = "*"
+ } else {
+ retval["If-Match"] = be.Entity.OdataEtag
+ }
+ }
+
+ return retval
+}
+
+// generateEntitySubset generates body payload for particular batch entity
+func (t *TableBatch) generateEntitySubset(batchEntity *BatchEntity, writer *multipart.Writer) error {
+
+ h := make(textproto.MIMEHeader)
+ h.Set(headerContentType, "application/http")
+ h.Set(headerContentTransferEncoding, "binary")
+
+ verb, err := generateVerb(batchEntity.Op)
+ if err != nil {
+ return err
+ }
+
+ genericOpHeadersMap := generateGenericOperationHeaders(batchEntity)
+ queryPath := t.generateQueryPath(batchEntity.Op, batchEntity.Entity)
+ uri := t.Table.tsc.client.getEndpoint(tableServiceName, queryPath, nil)
+
+ operationWriter, err := writer.CreatePart(h)
+ if err != nil {
+ return err
+ }
+
+ urlAndVerb := fmt.Sprintf("%s %s HTTP/1.1\r\n", verb, uri)
+ operationWriter.Write([]byte(urlAndVerb))
+ writeHeaders(genericOpHeadersMap, &operationWriter)
+ operationWriter.Write([]byte("\r\n")) // additional \r\n is needed per changeset separating the "headers" and the body.
+
+ // delete operation doesn't need a body.
+ if batchEntity.Op != DeleteOp {
+ //var e Entity = batchEntity.Entity
+ body, err := json.Marshal(batchEntity.Entity)
+ if err != nil {
+ return err
+ }
+ operationWriter.Write(body)
+ }
+
+ return nil
+}
+
+func writeHeaders(h map[string]string, writer *io.Writer) {
+ // This way it is guaranteed the headers will be written in a sorted order
+ var keys []string
+ for k := range h {
+ keys = append(keys, k)
+ }
+ sort.Strings(keys)
+ for _, k := range keys {
+ (*writer).Write([]byte(fmt.Sprintf("%s: %s\r\n", k, h[k])))
+ }
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/tableserviceclient.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/tableserviceclient.go
new file mode 100644
index 00000000000..1f063a39520
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/tableserviceclient.go
@@ -0,0 +1,204 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "strconv"
+)
+
+const (
+ headerAccept = "Accept"
+ headerEtag = "Etag"
+ headerPrefer = "Prefer"
+ headerXmsContinuation = "x-ms-Continuation-NextTableName"
+)
+
+// TableServiceClient contains operations for Microsoft Azure Table Storage
+// Service.
+type TableServiceClient struct {
+ client Client
+ auth authentication
+}
+
+// TableOptions includes options for some table operations
+type TableOptions struct {
+ RequestID string
+}
+
+func (options *TableOptions) addToHeaders(h map[string]string) map[string]string {
+ if options != nil {
+ h = addToHeaders(h, "x-ms-client-request-id", options.RequestID)
+ }
+ return h
+}
+
+// QueryNextLink includes information for getting the next page of
+// results in query operations
+type QueryNextLink struct {
+ NextLink *string
+ ml MetadataLevel
+}
+
+// GetServiceProperties gets the properties of your storage account's table service.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/get-table-service-properties
+func (t *TableServiceClient) GetServiceProperties() (*ServiceProperties, error) {
+ return t.client.getServiceProperties(tableServiceName, t.auth)
+}
+
+// SetServiceProperties sets the properties of your storage account's table service.
+// See: https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/set-table-service-properties
+func (t *TableServiceClient) SetServiceProperties(props ServiceProperties) error {
+ return t.client.setServiceProperties(props, tableServiceName, t.auth)
+}
+
+// GetTableReference returns a Table object for the specified table name.
+func (t *TableServiceClient) GetTableReference(name string) *Table {
+ return &Table{
+ tsc: t,
+ Name: name,
+ }
+}
+
+// QueryTablesOptions includes options for some table operations
+type QueryTablesOptions struct {
+ Top uint
+ Filter string
+ RequestID string
+}
+
+func (options *QueryTablesOptions) getParameters() (url.Values, map[string]string) {
+ query := url.Values{}
+ headers := map[string]string{}
+ if options != nil {
+ if options.Top > 0 {
+ query.Add(OdataTop, strconv.FormatUint(uint64(options.Top), 10))
+ }
+ if options.Filter != "" {
+ query.Add(OdataFilter, options.Filter)
+ }
+ headers = addToHeaders(headers, "x-ms-client-request-id", options.RequestID)
+ }
+ return query, headers
+}
+
+// QueryTables returns the tables in the storage account.
+// You can use query options defined by the OData Protocol specification.
+//
+// See https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/query-tables
+func (t *TableServiceClient) QueryTables(ml MetadataLevel, options *QueryTablesOptions) (*TableQueryResult, error) {
+ query, headers := options.getParameters()
+ uri := t.client.getEndpoint(tableServiceName, tablesURIPath, query)
+ return t.queryTables(uri, headers, ml)
+}
+
+// NextResults returns the next page of results
+// from a QueryTables or a NextResults operation.
+//
+// See https://docs.microsoft.com/rest/api/storageservices/fileservices/query-tables
+// See https://docs.microsoft.com/rest/api/storageservices/fileservices/query-timeout-and-pagination
+func (tqr *TableQueryResult) NextResults(options *TableOptions) (*TableQueryResult, error) {
+ if tqr == nil {
+ return nil, errNilPreviousResult
+ }
+ if tqr.NextLink == nil {
+ return nil, errNilNextLink
+ }
+ headers := options.addToHeaders(map[string]string{})
+
+ return tqr.tsc.queryTables(*tqr.NextLink, headers, tqr.ml)
+}
+
+// TableQueryResult contains the response from
+// QueryTables and QueryTablesNextResults functions.
+type TableQueryResult struct {
+ OdataMetadata string `json:"odata.metadata"`
+ Tables []Table `json:"value"`
+ QueryNextLink
+ tsc *TableServiceClient
+}
+
+func (t *TableServiceClient) queryTables(uri string, headers map[string]string, ml MetadataLevel) (*TableQueryResult, error) {
+ if ml == EmptyPayload {
+ return nil, errEmptyPayload
+ }
+ headers = mergeHeaders(headers, t.client.getStandardHeaders())
+ headers[headerAccept] = string(ml)
+
+ resp, err := t.client.exec(http.MethodGet, uri, headers, nil, t.auth)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if err := checkRespCode(resp, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ respBody, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+ var out TableQueryResult
+ err = json.Unmarshal(respBody, &out)
+ if err != nil {
+ return nil, err
+ }
+
+ for i := range out.Tables {
+ out.Tables[i].tsc = t
+ }
+ out.tsc = t
+
+ nextLink := resp.Header.Get(http.CanonicalHeaderKey(headerXmsContinuation))
+ if nextLink == "" {
+ out.NextLink = nil
+ } else {
+ originalURI, err := url.Parse(uri)
+ if err != nil {
+ return nil, err
+ }
+ v := originalURI.Query()
+ v.Set(nextTableQueryParameter, nextLink)
+ newURI := t.client.getEndpoint(tableServiceName, tablesURIPath, v)
+ out.NextLink = &newURI
+ out.ml = ml
+ }
+
+ return &out, nil
+}
+
+func addBodyRelatedHeaders(h map[string]string, length int) map[string]string {
+ h[headerContentType] = "application/json"
+ h[headerContentLength] = fmt.Sprintf("%v", length)
+ h[headerAcceptCharset] = "UTF-8"
+ return h
+}
+
+func addReturnContentHeaders(h map[string]string, ml MetadataLevel) map[string]string {
+ if ml != EmptyPayload {
+ h[headerPrefer] = "return-content"
+ h[headerAccept] = string(ml)
+ } else {
+ h[headerPrefer] = "return-no-content"
+ // From API version 2015-12-11 onwards, Accept header is required
+ h[headerAccept] = string(NoMetadata)
+ }
+ return h
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/storage/util.go b/vendor/github.com/Azure/azure-sdk-for-go/storage/util.go
new file mode 100644
index 00000000000..677394790df
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/storage/util.go
@@ -0,0 +1,260 @@
+package storage
+
+// Copyright 2017 Microsoft Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import (
+ "bytes"
+ "crypto/hmac"
+ "crypto/rand"
+ "crypto/sha256"
+ "encoding/base64"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "reflect"
+ "strconv"
+ "strings"
+ "time"
+
+ uuid "github.com/satori/go.uuid"
+)
+
+var (
+ fixedTime = time.Date(2050, time.December, 20, 21, 55, 0, 0, time.FixedZone("GMT", -6))
+ accountSASOptions = AccountSASTokenOptions{
+ Services: Services{
+ Blob: true,
+ },
+ ResourceTypes: ResourceTypes{
+ Service: true,
+ Container: true,
+ Object: true,
+ },
+ Permissions: Permissions{
+ Read: true,
+ Write: true,
+ Delete: true,
+ List: true,
+ Add: true,
+ Create: true,
+ Update: true,
+ Process: true,
+ },
+ Expiry: fixedTime,
+ UseHTTPS: true,
+ }
+)
+
+func (c Client) computeHmac256(message string) string {
+ h := hmac.New(sha256.New, c.accountKey)
+ h.Write([]byte(message))
+ return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func currentTimeRfc1123Formatted() string {
+ return timeRfc1123Formatted(time.Now().UTC())
+}
+
+func timeRfc1123Formatted(t time.Time) string {
+ return t.Format(http.TimeFormat)
+}
+
+func timeRFC3339Formatted(t time.Time) string {
+ return t.Format("2006-01-02T15:04:05.0000000Z")
+}
+
+func mergeParams(v1, v2 url.Values) url.Values {
+ out := url.Values{}
+ for k, v := range v1 {
+ out[k] = v
+ }
+ for k, v := range v2 {
+ vals, ok := out[k]
+ if ok {
+ vals = append(vals, v...)
+ out[k] = vals
+ } else {
+ out[k] = v
+ }
+ }
+ return out
+}
+
+func prepareBlockListRequest(blocks []Block) string {
+ s := ``
+ for _, v := range blocks {
+ s += fmt.Sprintf("<%s>%s", v.Status, v.ID, v.Status)
+ }
+ s += ``
+ return s
+}
+
+func xmlUnmarshal(body io.Reader, v interface{}) error {
+ data, err := ioutil.ReadAll(body)
+ if err != nil {
+ return err
+ }
+ return xml.Unmarshal(data, v)
+}
+
+func xmlMarshal(v interface{}) (io.Reader, int, error) {
+ b, err := xml.Marshal(v)
+ if err != nil {
+ return nil, 0, err
+ }
+ return bytes.NewReader(b), len(b), nil
+}
+
+func headersFromStruct(v interface{}) map[string]string {
+ headers := make(map[string]string)
+ value := reflect.ValueOf(v)
+ for i := 0; i < value.NumField(); i++ {
+ key := value.Type().Field(i).Tag.Get("header")
+ if key != "" {
+ reflectedValue := reflect.Indirect(value.Field(i))
+ var val string
+ if reflectedValue.IsValid() {
+ switch reflectedValue.Type() {
+ case reflect.TypeOf(fixedTime):
+ val = timeRfc1123Formatted(reflectedValue.Interface().(time.Time))
+ case reflect.TypeOf(uint64(0)), reflect.TypeOf(uint(0)):
+ val = strconv.FormatUint(reflectedValue.Uint(), 10)
+ case reflect.TypeOf(int(0)):
+ val = strconv.FormatInt(reflectedValue.Int(), 10)
+ default:
+ val = reflectedValue.String()
+ }
+ }
+ if val != "" {
+ headers[key] = val
+ }
+ }
+ }
+ return headers
+}
+
+// merges extraHeaders into headers and returns headers
+func mergeHeaders(headers, extraHeaders map[string]string) map[string]string {
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+ return headers
+}
+
+func addToHeaders(h map[string]string, key, value string) map[string]string {
+ if value != "" {
+ h[key] = value
+ }
+ return h
+}
+
+func addTimeToHeaders(h map[string]string, key string, value *time.Time) map[string]string {
+ if value != nil {
+ h = addToHeaders(h, key, timeRfc1123Formatted(*value))
+ }
+ return h
+}
+
+func addTimeout(params url.Values, timeout uint) url.Values {
+ if timeout > 0 {
+ params.Add("timeout", fmt.Sprintf("%v", timeout))
+ }
+ return params
+}
+
+func addSnapshot(params url.Values, snapshot *time.Time) url.Values {
+ if snapshot != nil {
+ params.Add("snapshot", timeRFC3339Formatted(*snapshot))
+ }
+ return params
+}
+
+func getTimeFromHeaders(h http.Header, key string) (*time.Time, error) {
+ var out time.Time
+ var err error
+ outStr := h.Get(key)
+ if outStr != "" {
+ out, err = time.Parse(time.RFC1123, outStr)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return &out, nil
+}
+
+// TimeRFC1123 is an alias for time.Time needed for custom Unmarshalling
+type TimeRFC1123 time.Time
+
+// UnmarshalXML is a custom unmarshaller that overrides the default time unmarshal which uses a different time layout.
+func (t *TimeRFC1123) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+ var value string
+ d.DecodeElement(&value, &start)
+ parse, err := time.Parse(time.RFC1123, value)
+ if err != nil {
+ return err
+ }
+ *t = TimeRFC1123(parse)
+ return nil
+}
+
+// MarshalXML marshals using time.RFC1123.
+func (t *TimeRFC1123) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+ return e.EncodeElement(time.Time(*t).Format(time.RFC1123), start)
+}
+
+// returns a map of custom metadata values from the specified HTTP header
+func getMetadataFromHeaders(header http.Header) map[string]string {
+ metadata := make(map[string]string)
+ for k, v := range header {
+ // Can't trust CanonicalHeaderKey() to munge case
+ // reliably. "_" is allowed in identifiers:
+ // https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+ // https://msdn.microsoft.com/library/aa664670(VS.71).aspx
+ // http://tools.ietf.org/html/rfc7230#section-3.2
+ // ...but "_" is considered invalid by
+ // CanonicalMIMEHeaderKey in
+ // https://golang.org/src/net/textproto/reader.go?s=14615:14659#L542
+ // so k can be "X-Ms-Meta-Lol" or "x-ms-meta-lol_rofl".
+ k = strings.ToLower(k)
+ if len(v) == 0 || !strings.HasPrefix(k, strings.ToLower(userDefinedMetadataHeaderPrefix)) {
+ continue
+ }
+ // metadata["lol"] = content of the last X-Ms-Meta-Lol header
+ k = k[len(userDefinedMetadataHeaderPrefix):]
+ metadata[k] = v[len(v)-1]
+ }
+
+ if len(metadata) == 0 {
+ return nil
+ }
+
+ return metadata
+}
+
+// newUUID returns a new uuid using RFC 4122 algorithm.
+func newUUID() (uuid.UUID, error) {
+ u := [16]byte{}
+ // Set all bits to randomly (or pseudo-randomly) chosen values.
+ _, err := rand.Read(u[:])
+ if err != nil {
+ return uuid.UUID{}, err
+ }
+ u[8] = (u[8]&(0xff>>2) | (0x02 << 6)) // u.setVariant(ReservedRFC4122)
+ u[6] = (u[6] & 0xF) | (uuid.V4 << 4) // u.setVersion(V4)
+ return uuid.FromBytes(u[:])
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/LICENSE b/vendor/github.com/Microsoft/azure-vhd-utils/LICENSE
new file mode 100644
index 00000000000..03000e7a916
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/LICENSE
@@ -0,0 +1,17 @@
+------------------------------------------ START OF LICENSE -----------------------------------------
+
+Azure VHD Utilities for Go
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+----------------------------------------------- END OF LICENSE ------------------------------------------
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/balancer.go b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/balancer.go
new file mode 100644
index 00000000000..03e7cb6e6c4
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/balancer.go
@@ -0,0 +1,142 @@
+package concurrent
+
+import (
+ "container/heap"
+ "time"
+)
+
+// Balancer is a type that can balance load among a set of workers
+//
+type Balancer struct {
+ errorChan chan error // The channel used by all workers to report error
+ requestHandledChan chan *Worker // The channel used by a worker to signal balancer that a work has been executed
+ tearDownChan chan bool // The channel that all workers listening for force quit signal
+ workerFinishedChan chan *Worker // The channel that all worker used to signal balancer that it exiting
+ allWorkersFinishedChan chan bool // The channel this balancer signals once all worker signals it's exit on workerFinishedChan
+ pool Pool // Pool of workers that this load balancer balances
+ workerCount int // The number of workers
+}
+
+// The size of work channel associated with each worker this balancer manages.
+//
+const workerQueueSize int = 3
+
+// NewBalancer creates a new instance of Balancer that needs to balance load between 'workerCount' workers
+//
+func NewBalancer(workerCount int) *Balancer {
+ balancer := &Balancer{
+ workerCount: workerCount,
+ pool: Pool{
+ Workers: make([]*Worker, workerCount),
+ },
+ }
+ return balancer
+}
+
+// Init initializes all channels and start the workers.
+//
+func (b *Balancer) Init() {
+ b.errorChan = make(chan error, 0)
+ b.requestHandledChan = make(chan *Worker, 0)
+ b.workerFinishedChan = make(chan *Worker, 0)
+ b.allWorkersFinishedChan = make(chan bool, 0)
+ b.tearDownChan = make(chan bool, 0)
+ for i := 0; i < b.workerCount; i++ {
+ b.pool.Workers[i] = NewWorker(i, workerQueueSize, &(b.pool), b.errorChan, b.requestHandledChan, b.workerFinishedChan)
+ (b.pool.Workers[i]).Run(b.tearDownChan)
+ }
+}
+
+// TearDownWorkers sends a force quit signal to all workers, which case worker to quit as soon as possible,
+// workers won't drain it's request channel in this case.
+//
+func (b *Balancer) TearDownWorkers() {
+ close(b.tearDownChan)
+}
+
+// Run read request from the request channel identified by the parameter requestChan and dispatch it the worker
+// with least load. This method returns two channels, a channel to communicate error from any worker back to
+// the consumer of balancer and second channel is used by the balancer to signal consumer that all workers has
+// been finished executing.
+//
+func (b *Balancer) Run(requestChan <-chan *Request) (<-chan error, <-chan bool) {
+ // Request dispatcher
+ go func() {
+ for {
+ requestToHandle, ok := <-requestChan
+ if !ok {
+ b.closeWorkersRequestChannel()
+ return
+ }
+ b.dispatch(requestToHandle)
+ }
+ }()
+
+ // listener for worker status
+ go func() {
+ remainingWorkers := b.workerCount
+ for {
+ select {
+ case w := <-b.requestHandledChan:
+ b.completed(w)
+ case _ = <-b.workerFinishedChan:
+ remainingWorkers--
+ if remainingWorkers == 0 {
+ b.allWorkersFinishedChan <- true // All workers has been exited
+ return
+ }
+ }
+ }
+ }()
+
+ return b.errorChan, b.allWorkersFinishedChan
+}
+
+// closeWorkersRequestChannel closes the Request channel of all workers, this indicates that no
+// more work will not be send the channel so that the workers can gracefully exit after handling
+// any pending work in the channel.
+//
+func (b *Balancer) closeWorkersRequestChannel() {
+ for i := 0; i < b.workerCount; i++ {
+ close((b.pool.Workers[i]).RequestsToHandleChan)
+ }
+}
+
+// dispatch dispatches the request to the worker with least load. If all workers are completely
+// busy (i.e. there Pending request count is currently equal to the maximum load) then this
+// method will poll until one worker is available.
+//
+func (b *Balancer) dispatch(request *Request) {
+ for {
+ if b.pool.Workers[0].Pending >= workerQueueSize {
+ // Wait for a worker to be available
+ time.Sleep(500 * time.Millisecond)
+ } else {
+ b.pool.Lock()
+ worker := b.pool.Workers[0]
+ worker.Pending++
+ heap.Fix(&b.pool, worker.Index)
+ worker.RequestsToHandleChan <- request
+ b.pool.Unlock()
+ return
+ }
+ }
+}
+
+// completed is called when a worker finishes one work, it updates the load status of the given the
+// worker.
+//
+func (b *Balancer) completed(worker *Worker) {
+ b.pool.Lock()
+ worker.Pending--
+ heap.Fix(&b.pool, worker.Index)
+ b.pool.Unlock()
+}
+
+// WorkersCurrentLoad returns the load of the workers this balancer manages as comma separated string
+// values where each value consists of worker id (Worker.Id property) and pending requests associated
+// with the worker.
+//
+func (b *Balancer) WorkersCurrentLoad() string {
+ return b.pool.WorkersCurrentLoad()
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/pool.go b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/pool.go
new file mode 100644
index 00000000000..00cf9b6b120
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/pool.go
@@ -0,0 +1,76 @@
+package concurrent
+
+import (
+ "bytes"
+ "fmt"
+ "sync"
+)
+
+// Pool is the collection of Worker, it is a min-heap that implements heap.Interface.
+// The priority is the number of pending works assigned to the worker. Lower the pending
+// work count higher the priority. Pool embeds sync.RWMutex to support concurrent heap
+// operation.
+//
+type Pool struct {
+ sync.RWMutex // If consumer want to use workers in a concurrent environment
+ Workers []*Worker // The workers
+}
+
+// Len returns number of workers in the pool.
+//
+func (p *Pool) Len() int {
+ return len(p.Workers)
+}
+
+// Less returns true if priority of Worker instance at index i is less than priority of Worker
+// instance at j, lower the pending value higher the priority
+//
+func (p *Pool) Less(i, j int) bool {
+ return p.Workers[i].Pending < p.Workers[j].Pending
+}
+
+// Swap swaps the Worker instances at the given indices i and j
+//
+func (p Pool) Swap(i, j int) {
+ p.Workers[i], p.Workers[j] = p.Workers[j], p.Workers[i]
+ p.Workers[i].Index = i
+ p.Workers[j].Index = j
+}
+
+// Push is used by heap.Push implementation, to add a worker w to a Pool pool, we call
+// heap.Push(&pool, w) which invokes this method to add the worker to the end of collection
+// then it fix the heap by moving the added item to its correct position.
+//
+func (p *Pool) Push(x interface{}) {
+ n := len(p.Workers)
+ worker := x.(*Worker)
+ worker.Index = n
+ (*p).Workers = append((*p).Workers, worker)
+}
+
+// Pop is used by heap.Pop implementation, to pop a worker w with minimum priority from a Pool
+// p, we call w := heap.Pop(&p).(*Worker), which swap the min priority worker at the beginning
+// of the pool with the end of item, fix the heap and then invokes this method for popping the
+// worker from the end.
+//
+func (p *Pool) Pop() interface{} {
+ n := len(p.Workers)
+ w := (*p).Workers[n-1]
+ w.Index = -1
+ (*p).Workers = (*p).Workers[0 : n-1]
+ return w
+}
+
+// WorkersCurrentLoad returns the load of the workers as comma separated string values, where
+// each value consists of worker id (Worker.Id property) and pending requests associated with
+// the worker.
+//
+func (p *Pool) WorkersCurrentLoad() string {
+ var buffer bytes.Buffer
+ buffer.WriteString("Load [")
+ for _, w := range p.Workers {
+ buffer.WriteString(fmt.Sprintf("%d:%d, ", w.ID, w.Pending))
+ }
+ buffer.WriteString("]")
+ return buffer.String()
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/request.go b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/request.go
new file mode 100644
index 00000000000..8f9ef99f9e7
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/request.go
@@ -0,0 +1,9 @@
+package concurrent
+
+// Request represents a work that Worker needs to execute
+//
+type Request struct {
+ ID string // The Id of the work (for debugging purposes)
+ Work func() error // The work to be executed by a worker
+ ShouldRetry func(err error) bool // The method used by worker to decide whether to retry if work execution fails
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/worker.go b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/worker.go
new file mode 100644
index 00000000000..99c340adaf1
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/upload/concurrent/worker.go
@@ -0,0 +1,117 @@
+package concurrent
+
+import "fmt"
+
+// Worker represents a type which can listen for work from a channel and run them
+//
+type Worker struct {
+ RequestsToHandleChan chan *Request // The buffered channel of works this worker needs to handle
+ Pending int // The number of pending requests this worker needs to handle (i.e. worker load)
+ errorChan chan<- error // The channel to report failure in executing work
+ requestHandledChan chan<- *Worker // The channel to report that a work is done (irrespective of success or failure)
+ workerFinishedChan chan<- *Worker // The channel to signal that worker has finished (worker go-routine exited)
+ ID int // Unique Id for worker (Debugging purpose)
+ Index int // The index of the item in the heap.
+ pool *Pool // The parent pool holding all workers (used for work stealing)
+}
+
+// The maximum number of times a work needs to be retried before reporting failure on errorChan.
+//
+const maxRetryCount int = 5
+
+// NewWorker creates a new instance of the worker with the given work channel size.
+// errorChan is the channel to report the failure in addressing a work request after all
+// retries, each time a work is completed (failure or success) doneChan will be signalled
+//
+func NewWorker(id int, workChannelSize int, pool *Pool, errorChan chan<- error, requestHandledChan chan<- *Worker, workerFinishedChan chan<- *Worker) *Worker {
+ return &Worker{
+ ID: id,
+ RequestsToHandleChan: make(chan *Request, workChannelSize),
+ errorChan: errorChan,
+ requestHandledChan: requestHandledChan,
+ workerFinishedChan: workerFinishedChan,
+ pool: pool,
+ }
+}
+
+// Run starts a go-routine that read work from work-queue associated with the worker and executes one
+// at a time. The go-routine returns/exit once one of the following condition is met:
+// 1. The work-queue is closed and drained and there is no work to steal from peers worker's work-queue
+// 2. A signal is received in the tearDownChan channel parameter
+//
+// After executing each work, this method sends report to Worker::requestHandledChan channel
+// If a work fails after maximum retry, this method sends report to Worker::errorChan channel
+//
+func (w *Worker) Run(tearDownChan <-chan bool) {
+ go func() {
+ defer func() {
+ // Signal balancer that worker is finished
+ w.workerFinishedChan <- w
+ }()
+
+ var requestToHandle *Request
+ var ok bool
+ for {
+ select {
+ case requestToHandle, ok = <-w.RequestsToHandleChan:
+ if !ok {
+ // Request channel is closed and drained, worker can try to steal work from others.
+ //
+ // Note: load balancer does not play any role in stealing, load balancer closes send-end
+ // of all worker queue's at the same time, at this point we are sure that no more new job
+ // will be scheduled. Once we start stealing "Worker::Pending" won't reflect correct load.
+ requestToHandle = w.tryStealWork()
+ if requestToHandle == nil {
+ // Could not steal then return
+ return
+ }
+ }
+ case <-tearDownChan:
+ // immediate stop, no need to drain the request channel
+ return
+ }
+
+ var err error
+ // Do work, retry on failure.
+ Loop:
+ for count := 0; count < maxRetryCount+1; count++ {
+ select {
+ case <-tearDownChan:
+ return
+ default:
+ err = requestToHandle.Work() // Run work
+ if err == nil || !requestToHandle.ShouldRetry(err) {
+ break Loop
+ }
+ }
+ }
+
+ if err != nil {
+ select {
+ case w.errorChan <- fmt.Errorf("%s: %v", requestToHandle.ID, err):
+ case <-tearDownChan:
+ return
+ }
+ }
+
+ select {
+ case w.requestHandledChan <- w: // One work finished (successfully or unsuccessfully)
+ case <-tearDownChan:
+ return
+ }
+ }
+ }()
+}
+
+// tryStealWork will try to steal a work from peer worker if available. If all peer channels are
+// empty then return nil
+//
+func (w *Worker) tryStealWork() *Request {
+ for _, w1 := range w.pool.Workers {
+ request, ok := <-w1.RequestsToHandleChan
+ if ok {
+ return request
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/computeStats.go b/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/computeStats.go
new file mode 100644
index 00000000000..126232221d6
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/computeStats.go
@@ -0,0 +1,46 @@
+package progress
+
+// ComputeStats type supports computing running average with a given window size.
+//
+type ComputeStats struct {
+ history []float64
+ size int
+ p int
+}
+
+// NewComputeStats returns a new instance of ComputeStats. The parameter size is the
+// maximum number of values that ComputeStats track at any given point of time.
+//
+func NewComputeStats(size int) *ComputeStats {
+ return &ComputeStats{
+ history: make([]float64, size),
+ size: size,
+ p: 0,
+ }
+}
+
+// NewComputestateDefaultSize returns a new instance of ComputeStats that can tracks
+// maximum of 60 values.
+//
+func NewComputestateDefaultSize() *ComputeStats {
+ return NewComputeStats(60)
+}
+
+// ComputeAvg adds the given value to a list containing set of previous values added
+// and returns the average of the values in the list. If the values list reached the
+// maximum size then oldest value will be removed
+//
+func (s *ComputeStats) ComputeAvg(current float64) float64 {
+ s.history[s.p] = current
+ s.p++
+ if s.p == s.size {
+ s.p = 0
+ }
+
+ sum := float64(0)
+ for i := 0; i < s.size; i++ {
+ sum += s.history[i]
+ }
+
+ return sum / float64(s.size)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/readerWithProgress.go b/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/readerWithProgress.go
new file mode 100644
index 00000000000..178e8e8883a
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/readerWithProgress.go
@@ -0,0 +1,46 @@
+package progress
+
+import (
+ "io"
+ "time"
+)
+
+// ReaderWithProgress wraps an io.ReadCloser, it track and report the read progress.
+//
+type ReaderWithProgress struct {
+ ProgressChan <-chan *Record
+ innerReadCloser io.ReadCloser
+ progressStatus *Status
+}
+
+// NewReaderWithProgress creates a new instance of ReaderWithProgress. The parameter inner is the inner stream whose
+// read progress needs to be tracked, sizeInBytes is the total size of the inner stream in bytes,
+// progressIntervalInSeconds is the interval at which the read progress needs to be send to ProgressChan channel.
+// After using the this reader, it must be closed by calling Close method to avoid goroutine leak.
+//
+func NewReaderWithProgress(inner io.ReadCloser, sizeInBytes int64, progressIntervalInSeconds time.Duration) *ReaderWithProgress {
+ r := &ReaderWithProgress{}
+ r.innerReadCloser = inner
+ r.progressStatus = NewStatus(0, 0, sizeInBytes, NewComputestateDefaultSize())
+ r.ProgressChan = r.progressStatus.Run()
+ return r
+}
+
+// Read reads up to len(b) bytes from the inner stream. It returns the number of bytes read and an error, if any.
+// EOF is signaled when no more data to read and n will set to 0.
+//
+func (r *ReaderWithProgress) Read(p []byte) (n int, err error) {
+ n, err = r.innerReadCloser.Read(p)
+ if err == nil {
+ r.progressStatus.ReportBytesProcessedCount(int64(n))
+ }
+ return
+}
+
+// Close closes the inner stream and stop reporting read progress in the ProgressChan chan.
+//
+func (r *ReaderWithProgress) Close() error {
+ err := r.innerReadCloser.Close()
+ r.progressStatus.Close()
+ return err
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/status.go b/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/status.go
new file mode 100644
index 00000000000..887342f5ef8
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/upload/progress/status.go
@@ -0,0 +1,138 @@
+package progress
+
+import (
+ "time"
+)
+
+// Status can be used by a collection of workers (reporters) to report the amount of work done when they need,
+// Status compute the overall progress at regular interval and report it.
+//
+type Status struct {
+ bytesProcessedCountChan chan int64
+ doneChan chan bool
+ bytesProcessed int64
+ totalBytes int64
+ alreadyProcessedBytes int64
+ startTime time.Time
+ throughputStats *ComputeStats
+}
+
+// Record type is used by the ProgressStatus to report the progress at regular interval.
+//
+type Record struct {
+ PercentComplete float64
+ AverageThroughputMbPerSecond float64
+ RemainingDuration time.Duration
+ BytesProcessed int64
+}
+
+// oneMB is one MegaByte
+//
+const oneMB = float64(1048576)
+
+// nanosecondsInOneSecond is 1 second expressed as nano-second unit
+//
+const nanosecondsInOneSecond = 1000 * 1000 * 1000
+
+// NewStatus creates a new instance of Status. reporterCount is the number of concurrent goroutines that want to
+// report processed bytes count, alreadyProcessedBytes is the bytes already processed if any, the parameter
+// totalBytes is the total number of bytes that the reports will be process eventually, the parameter computeStats
+// is used to calculate the running average.
+//
+func NewStatus(reportersCount int, alreadyProcessedBytes, totalBytes int64, computeStats *ComputeStats) *Status {
+ return &Status{
+ bytesProcessedCountChan: make(chan int64, reportersCount),
+ doneChan: make(chan bool, 0),
+ totalBytes: totalBytes,
+ alreadyProcessedBytes: alreadyProcessedBytes,
+ startTime: time.Now(),
+ throughputStats: computeStats,
+ }
+}
+
+// ReportBytesProcessedCount method is used to report the number of bytes processed.
+//
+func (s *Status) ReportBytesProcessedCount(count int64) {
+ s.bytesProcessedCountChan <- count
+}
+
+// Run starts counting the reported processed bytes count and compute the progress, this method returns a channel,
+// the computed progress will be send to this channel in regular interval. Once done with using ProgressStatus
+// instance, you must call Dispose method otherwise there will be go routine leak.
+//
+func (s *Status) Run() <-chan *Record {
+ go s.bytesProcessedCountReceiver()
+ var outChan = make(chan *Record, 0)
+ go s.progressRecordSender(outChan)
+ return outChan
+}
+
+// Close disposes this ProgressStatus instance, an attempt to invoke ReportBytesProcessedCount method on a closed
+// instance will be panic. Close also stops sending progress to the channel returned by Run method. Not calling
+// Close will cause goroutine leak.
+//
+func (s *Status) Close() {
+ close(s.bytesProcessedCountChan)
+}
+
+// bytesProcessedCountReceiver read the channel containing the collection of reported bytes count and update the total
+// bytes processed. This method signal doneChan when there is no more data to read.
+//
+func (s *Status) bytesProcessedCountReceiver() {
+ for c := range s.bytesProcessedCountChan {
+ s.bytesProcessed += c
+ }
+ s.doneChan <- true
+}
+
+// progressRecordSender compute the progress information at regular interval and send it to channel outChan which is
+// returned by the Run method
+//
+func (s *Status) progressRecordSender(outChan chan<- *Record) {
+ progressRecord := &Record{}
+ tickerChan := time.NewTicker(500 * time.Millisecond)
+Loop:
+ for {
+ select {
+ case <-tickerChan.C:
+ computeAvg := s.throughputStats.ComputeAvg(s.throughputMBs())
+ avtThroughputMbps := 8.0 * computeAvg
+ remainingSeconds := (s.remainingMB() / computeAvg)
+
+ progressRecord.PercentComplete = s.percentComplete()
+ progressRecord.RemainingDuration = time.Duration(nanosecondsInOneSecond * remainingSeconds)
+ progressRecord.AverageThroughputMbPerSecond = avtThroughputMbps
+ progressRecord.BytesProcessed = s.bytesProcessed
+
+ outChan <- progressRecord
+ case <-s.doneChan:
+ tickerChan.Stop()
+ break Loop
+ }
+ }
+ close(outChan)
+}
+
+// remainingMB returns remaining bytes to be processed as MB.
+//
+func (s *Status) remainingMB() float64 {
+ return float64(s.totalBytes-s.bytesProcessed) / oneMB
+}
+
+// percentComplete returns the percentage of bytes processed out of total bytes.
+//
+func (s *Status) percentComplete() float64 {
+ return float64(100.0) * (float64(s.bytesProcessed) / float64(s.totalBytes))
+}
+
+// processTime returns the Duration representing the time taken to process the bytes so far.
+//
+func (s *Status) processTime() time.Duration {
+ return time.Since(s.startTime)
+}
+
+// throughputMBs returns the throughput in MB
+//
+func (s *Status) throughputMBs() float64 {
+ return float64(s.bytesProcessed) / oneMB / s.processTime().Seconds()
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTable.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTable.go
new file mode 100644
index 00000000000..c5e6e835f18
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTable.go
@@ -0,0 +1,77 @@
+package bat
+
+import (
+ "math"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+)
+
+// BlockAllocationTable type represents the Block Allocation Table (BAT) of the disk, BAT served as
+// index to access the disk's blocks.
+// A block is a unit of expansion for dynamic and differencing hard disks. All blocks within a given
+// image must be the same size.
+// The number of entries in the BAT is the number of blocks needed to store the contents of the disk
+// when fully expanded. Each entry in this table is the absolute sector offset to a block. Each entry
+// is four bytes long. if the disk is not fully expanded then, even though BAT has entries reserved
+// for unexpanded blocks, the corresponding block will not exists. All such unused table entries
+// are initialized to 0xFFFFFFFF.
+// A block consists of two sections 'data section' and 'block bitmap section'. The 'BlockSize' field
+// of the disk header is the size of the 'data section' of the block, it does not include the size of
+// the 'block bitmap section'. Each bit in the bitmap indicates the state of the corresponding sector
+// in 'data section', 1 indicates sector contains valid data, 0 indicates the sector have never been
+// modified.
+//
+type BlockAllocationTable struct {
+ BATEntriesCount uint32
+ BAT []uint32
+ blockSize uint32
+}
+
+// NewBlockAllocationTable creates an instance of BlockAllocationTable, BAT is the block allocation table,
+// each entry in this table is the absolute sector offset to a block, blockSize is the size of block's
+// 'data section' in bytes.
+//
+func NewBlockAllocationTable(blockSize uint32, bat []uint32) *BlockAllocationTable {
+ return &BlockAllocationTable{BATEntriesCount: uint32(len(bat)), blockSize: blockSize, BAT: bat}
+}
+
+// GetBitmapSizeInBytes returns the size of the 'block bitmap section' that stores the state
+// of the sectors in block's 'data section'. This means the number of bits in the bitmap is equivalent
+// to the number of sectors in 'data section', dividing this number by 8 will yield the number of bytes
+// required to store the bitmap.
+// As per vhd specification sectors per block must be power of two. The sector length is always 512 bytes.
+// This means the block size will be power of two as well e.g. 512 * 2^3, 512 * 2^4, 512 * 2^5 etc..
+//
+func (b *BlockAllocationTable) GetBitmapSizeInBytes() int32 {
+ return int32(b.blockSize / uint32(vhdcore.VhdSectorLength) / 8)
+}
+
+// GetSectorPaddedBitmapSizeInBytes returns the size of the 'block bitmap section' in bytes which is
+// padded to a 512-byte sector boundary. The bitmap of a block is always padded to a 512-byte sector
+// boundary.
+func (b *BlockAllocationTable) GetSectorPaddedBitmapSizeInBytes() int32 {
+ sectorSizeInBytes := float64(vhdcore.VhdSectorLength)
+ bitmapSizeInBytes := float64(b.GetBitmapSizeInBytes())
+ return int32(math.Ceil(bitmapSizeInBytes/sectorSizeInBytes) * sectorSizeInBytes)
+}
+
+// GetBitmapAddress returns the address of the 'block bitmap section' of a given block. Address is the
+// absolute byte offset of the 'block bitmap section'. A block consists of 'block bitmap section' and
+// 'data section'
+//
+func (b *BlockAllocationTable) GetBitmapAddress(blockIndex uint32) int64 {
+ return int64(b.BAT[blockIndex]) * vhdcore.VhdSectorLength
+}
+
+// GetBlockDataAddress returns the address of the 'data section' of a given block. Address is the absolute
+// byte offset of the 'data section'. A block consists of 'block bitmap section' and 'data section'
+//
+func (b *BlockAllocationTable) GetBlockDataAddress(blockIndex uint32) int64 {
+ return b.GetBitmapAddress(blockIndex) + int64(b.GetSectorPaddedBitmapSizeInBytes())
+}
+
+// HasData returns true if the given block has not yet expanded hence contains no data.
+//
+func (b *BlockAllocationTable) HasData(blockIndex uint32) bool {
+ return blockIndex != vhdcore.VhdNoDataInt && b.BAT[blockIndex] != vhdcore.VhdNoDataInt
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTableFactory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTableFactory.go
new file mode 100644
index 00000000000..04d8c29a32d
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTableFactory.go
@@ -0,0 +1,45 @@
+package bat
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/header"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// BlockAllocationTableFactory type is used to create BlockAllocationTable instance by reading BAT
+// section of the disk which follows the header
+//
+type BlockAllocationTableFactory struct {
+ vhdReader *reader.VhdReader
+ vhdHeader *header.Header
+}
+
+// NewBlockAllocationFactory creates a new instance of BlockAllocationTableFactory, which can be used
+// to create BlockAllocationTable instance by reading BAT section of the Vhd.
+// vhdReader is the reader to be used to read the entry, vhdHeader is the header structure representing
+// the disk header.
+//
+func NewBlockAllocationFactory(vhdReader *reader.VhdReader, vhdHeader *header.Header) *BlockAllocationTableFactory {
+ return &BlockAllocationTableFactory{
+ vhdReader: vhdReader,
+ vhdHeader: vhdHeader,
+ }
+}
+
+// Create creates a BlockAllocationTable instance by reading the BAT section of the disk.
+// This function return error if any error occurs while reading or parsing the BAT entries.
+//
+func (f *BlockAllocationTableFactory) Create() (*BlockAllocationTable, error) {
+ var err error
+ batEntriesCount := f.vhdHeader.MaxTableEntries
+ batEntryOffset := f.vhdHeader.TableOffset
+ bat := make([]uint32, batEntriesCount)
+ for i := uint32(0); i < batEntriesCount; i++ {
+ bat[i], err = f.vhdReader.ReadUInt32(batEntryOffset)
+ if err != nil {
+ return nil, NewBlockAllocationTableParseError(i, err)
+ }
+
+ batEntryOffset += 4
+ }
+ return NewBlockAllocationTable(f.vhdHeader.BlockSize, bat), nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTableParseError.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTableParseError.go
new file mode 100644
index 00000000000..985b7f7e079
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/bat/blockAllocationTableParseError.go
@@ -0,0 +1,33 @@
+package bat
+
+import "fmt"
+
+// BlockAllocationTableParseError is the error type representing BAT parse error.
+//
+type BlockAllocationTableParseError struct {
+ BATItemIndex uint32
+ err error
+}
+
+// Error returns the string representation of the BlockAllocationTableParseError instance.
+//
+func (e *BlockAllocationTableParseError) Error() string {
+ return fmt.Sprintf("Parse BAT entry at '%d' failed: "+e.err.Error(), e.BATItemIndex)
+}
+
+// GetInnerErr returns the inner error, this method satisfies InnerErr interface
+//
+func (e *BlockAllocationTableParseError) GetInnerErr() error {
+ return e.err
+}
+
+// NewBlockAllocationTableParseError returns a new BlockAllocationTableParseError instance.
+// The parameter batItemIndex represents BAT index failed to parse
+// The parameter err is the underlying error for parse failure.
+//
+func NewBlockAllocationTableParseError(batItemIndex uint32, err error) error {
+ return &BlockAllocationTableParseError{
+ BATItemIndex: batItemIndex,
+ err: err,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/bitmap.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/bitmap.go
new file mode 100644
index 00000000000..c2bd67498bf
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/bitmap.go
@@ -0,0 +1,58 @@
+package bitmap
+
+import "fmt"
+
+// BitMap type represents 'bitmap section' of a block.
+//
+type BitMap struct {
+ data []byte
+ Length int32
+}
+
+// NewBitMapFromByteSlice creates a new BitMap, b is the byte slice that needs to be used as bitmap
+// source. The caller should not reuse this byte slice anymore.
+//
+func NewBitMapFromByteSlice(b []byte) *BitMap {
+ return &BitMap{data: b, Length: int32(len(b)) * 8}
+}
+
+// NewBitMapFromByteSliceCopy creates a new BitMap, b is the byte slice that needs to be used as bitmap
+// source. The caller can reuse the byte slice as this method creates a copy of it.
+//
+func NewBitMapFromByteSliceCopy(b []byte) *BitMap {
+ data := make([]byte, len(b))
+ copy(data, b)
+ return &BitMap{data: data, Length: int32(len(b)) * 8}
+}
+
+// Set sets the bit at the given index. It returns error if idx < 0 or idx >= bitsCount.
+//
+func (b *BitMap) Set(idx int32, value bool) error {
+ if idx < 0 || idx >= b.Length {
+ return fmt.Errorf("The index %d is out of boundary", idx)
+ }
+
+ i := idx >> 3
+ m := 1 << (uint32(idx) & 7)
+
+ if value {
+ b.data[i] = b.data[i] | byte(m)
+ } else {
+ b.data[i] = b.data[i] & byte(^m)
+ }
+
+ return nil
+}
+
+// Get returns the value of the bit at the given index. It returns error if idx < 0 or idx >= bitsCount.
+//
+func (b *BitMap) Get(idx int32) (bool, error) {
+ if idx < 0 || idx >= b.Length {
+ return false, fmt.Errorf("The index %d is out of boundary", idx)
+ }
+
+ i := idx >> 3
+ m := 1 << (uint32(idx) & 7)
+
+ return (b.data[i] & byte(m)) != 0, nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/factory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/factory.go
new file mode 100644
index 00000000000..5a9af9b0d52
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/factory.go
@@ -0,0 +1,36 @@
+package bitmap
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/bat"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// Factory type is used to create BitMap instance by reading 'bitmap section' of a block.
+//
+type Factory struct {
+ vhdReader *reader.VhdReader
+ blockAllocationTable *bat.BlockAllocationTable
+}
+
+// NewFactory creates a new instance of Factory, which can be used to create a BitMap instance by reading
+// the 'bitmap section' of a block. vhdReader is the reader to read the disk, blockAllocationTable wraps
+// the disk's BAT table, which has one entry per block, this is used to retrieve the absolute offset to
+// the beginning of the 'bitmap section' of a block and the size of the 'bitmap section'.
+//
+func NewFactory(vhdReader *reader.VhdReader, blockAllocationTable *bat.BlockAllocationTable) *Factory {
+ return &Factory{vhdReader: vhdReader, blockAllocationTable: blockAllocationTable}
+}
+
+// Create creates a BitMap instance by reading block's 'bitmap section', block is the index of the
+// block entry in the BAT whose 'bitmap section' needs to be read.
+// This function return error if any error occurs while reading or parsing the block's bitmap.
+//
+func (f *Factory) Create(blockIndex uint32) (*BitMap, error) {
+ bitmapAbsoluteByteOffset := f.blockAllocationTable.GetBitmapAddress(blockIndex)
+ bitmapSizeInBytes := f.blockAllocationTable.GetBitmapSizeInBytes()
+ bitmapBytes := make([]byte, bitmapSizeInBytes)
+ if _, err := f.vhdReader.ReadBytes(bitmapAbsoluteByteOffset, bitmapBytes); err != nil {
+ return nil, NewParseError(blockIndex, err)
+ }
+ return NewBitMapFromByteSlice(bitmapBytes), nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/parseError.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/parseError.go
new file mode 100644
index 00000000000..047b1243ed6
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap/parseError.go
@@ -0,0 +1,33 @@
+package bitmap
+
+import "fmt"
+
+// ParseError is the error type representing parsing error of a block's bitmap.
+//
+type ParseError struct {
+ BlockIndex uint32
+ err error
+}
+
+// Error returns the string representation of the BitmapParseError instance.
+//
+func (e *ParseError) Error() string {
+ return fmt.Sprintf("Parse Bitmap section of block '%d' failed: "+e.err.Error(), e.BlockIndex)
+}
+
+// GetInnerErr returns the inner error, this method satisfies InnerErr interface
+//
+func (e *ParseError) GetInnerErr() error {
+ return e.err
+}
+
+// NewParseError returns a new ParseError instance.
+// The parameter blockIndex represents index of the block whose bitmap failed to parse
+// The parameter err is the underlying error for parse failure.
+//
+func NewParseError(blockIndex uint32, err error) error {
+ return &ParseError{
+ BlockIndex: blockIndex,
+ err: err,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/block.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/block.go
new file mode 100644
index 00000000000..c24aad104e3
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/block.go
@@ -0,0 +1,79 @@
+package block
+
+import (
+ "fmt"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+)
+
+// Block type represents Block of a vhd. A block of a dynamic or differential vhd starts with a
+// 'bitmap' section followed by the 'data' section, in case of fixed vhd the entire block is used
+// to store the 'data'.
+//
+type Block struct {
+ // BlockIndex is the index of the block, block indices are consecutive values starting from 0
+ // for the first block.
+ BlockIndex uint32
+ // IsEmpty is true if the block is empty, for dynamic and differencing disk the BAT entry of an
+ // empty block contains 0xFFFFFFFF.
+ IsEmpty bool
+ // BitMap represents 'bitmap section' of the block. Each bit in the bitmap represents the state
+ // of a sector in the block.
+ //
+ // This field is always nil for fixed disk. For Dynamic and differencing disk this field is set
+ // if the block is not marked as empty in the BAT.
+ //
+ // The dynamic and differencing subsystem reads the sector marked as dirty from the current disk,
+ // if a sector is marked as clean and if the current disk disk is dynamic then the sector will be
+ // read from the parent disk.
+ BitMap *bitmap.BitMap
+ // LogicalRange holds the absolute start and end byte offset of the block's 'data' in the converted
+ // fixed disk. When converting dynamic and differential vhd to fixed vhd, we place all block's 'data'
+ // consecutively starting at byte offset 0 of the fixed disk.
+ LogicalRange *common.IndexRange
+ // VhdUniqueId holds the unique identifier of the vhd that the block belongs to. The vhd unique
+ // identifier is stored in the vhd footer unique id field.
+ VhdUniqueID *common.UUID
+ // BlockData is a byte slice containing the block's 'data'
+ blockData []byte
+ // blockDataReader is the reader for reading the block's 'data' from the disk.
+ BlockDataReader DataReader
+ // sectorProvider enables retrieving the sector
+ blockFactory Factory
+}
+
+// Data returns the block data, the content of entire block in case of fixed vhd and the content
+// of block's data section in case of dynamic and differential vhd.
+//
+func (b *Block) Data() ([]byte, error) {
+ if b.blockData == nil {
+ var err error
+ b.blockData, err = b.BlockDataReader.Read(b)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return b.blockData, nil
+}
+
+// GetSector returns an instance of Sector representing a sector with the given Id in this block.
+// The parameter sectorIndex is the index of the sector in this block to read.
+//
+func (b *Block) GetSector(sectorIndex uint32) (*Sector, error) {
+ return b.blockFactory.GetSector(b, sectorIndex)
+}
+
+// GetSectorCount returns the number of sectors in the block.
+//
+func (b *Block) GetSectorCount() int64 {
+ return b.LogicalRange.Length() / vhdcore.VhdSectorLength
+}
+
+// String returns formatted representation of the block
+// This satisfies Stringer interface.
+//
+func (b *Block) String() string {
+ return fmt.Sprintf("Block:%d", b.BlockIndex)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dataReadError.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dataReadError.go
new file mode 100644
index 00000000000..8b5bbd3b263
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dataReadError.go
@@ -0,0 +1,39 @@
+package block
+
+import (
+ "fmt"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+)
+
+// DataReadError is the error type representing block data read error.
+//
+type DataReadError struct {
+ BlockIndex uint32
+ DiskType footer.DiskType
+ err error
+}
+
+// Error returns the string representation of the BlockDataReadError instance.
+//
+func (e *DataReadError) Error() string {
+ return fmt.Sprintf("Error in Reading block '%d', DiskType - %s : %s", e.BlockIndex, e.DiskType, e.err)
+}
+
+// GetInnerErr returns the inner error, this method satisfies InnerErr interface
+//
+func (e *DataReadError) GetInnerErr() error {
+ return e.err
+}
+
+// NewDataReadError returns a new DataReadError instance.
+// The parameter blockIndex represents index of the block whose bitmap failed to parse
+// The parameter err is the underlying error for parse failure.
+//
+func NewDataReadError(blockIndex uint32, diskType footer.DiskType, err error) error {
+ return &DataReadError{
+ BlockIndex: blockIndex,
+ DiskType: diskType,
+ err: err,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dataReader.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dataReader.go
new file mode 100644
index 00000000000..3cea537ce94
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dataReader.go
@@ -0,0 +1,10 @@
+package block
+
+// DataReader interface that all block readers specific to disk type (fixed,
+// dynamic, differencing) needs to satisfy.
+//
+type DataReader interface {
+ // Read reads the disk block identified by the parameter block
+ //
+ Read(block *Block) ([]byte, error)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/differencingDiskBlockFactory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/differencingDiskBlockFactory.go
new file mode 100644
index 00000000000..e70bb288857
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/differencingDiskBlockFactory.go
@@ -0,0 +1,138 @@
+package block
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+)
+
+// DifferencingDiskBlockFactory is a type which is used for following purposes
+// To create a Block instance representing a differencing disk block
+// To get the number of blocks in the differencing disk
+// To get the block size of the block in differencing disk
+// To get a Sector instance representing sector of differencing disk's block
+// To get the logical footer range of fixed disk generated from the differencing disk and it's parents.
+//
+type DifferencingDiskBlockFactory struct {
+ params *FactoryParams
+ bitmapFactory *bitmap.Factory
+ sectorFactory *SectorFactory
+ blockDataReader DataReader
+ cachedBlock *Block
+}
+
+// NewDifferencingDiskBlockFactory creates a DifferencingDiskBlockFactory instance which can be used to
+// create a Block objects representing differential disk block of a size specified in header BlockSize
+// field parameter vhdFile represents the differencing disk.
+//
+func NewDifferencingDiskBlockFactory(params *FactoryParams) *DifferencingDiskBlockFactory {
+ blockFactory := &DifferencingDiskBlockFactory{params: params}
+
+ blockFactory.bitmapFactory = bitmap.NewFactory(blockFactory.params.VhdReader,
+ blockFactory.params.BlockAllocationTable)
+
+ blockFactory.sectorFactory = NewSectorFactory(blockFactory.params.VhdReader,
+ blockFactory.params.BlockAllocationTable.HasData,
+ blockFactory.params.BlockAllocationTable.GetBlockDataAddress)
+
+ blockFactory.blockDataReader = NewDifferencingDiskBlockReader(blockFactory.params.VhdReader,
+ blockFactory.params.BlockAllocationTable,
+ blockFactory.params.VhdHeader.BlockSize)
+
+ return blockFactory
+}
+
+// GetBlockCount returns the number of blocks in the differential disk.
+//
+func (f *DifferencingDiskBlockFactory) GetBlockCount() int64 {
+ return int64(f.params.BlockAllocationTable.BATEntriesCount)
+}
+
+// GetBlockSize returns the size of the 'data section' of block in bytes in the differential disk.
+//
+func (f *DifferencingDiskBlockFactory) GetBlockSize() int64 {
+ return int64(f.params.VhdHeader.BlockSize)
+}
+
+// GetFooterRange returns the logical range of the footer when converting this differential vhd to
+// fixed logical range of footer is the absolute start and end byte offset of the footer.
+//
+func (f *DifferencingDiskBlockFactory) GetFooterRange() *common.IndexRange {
+ return common.NewIndexRangeFromLength(f.GetBlockCount()*f.GetBlockSize(), vhdcore.VhdFooterSize)
+}
+
+// Create returns an instance of Block which represents a differencing disk block, the parameter blockIndex
+// identifies the block. If the block to be read is marked as empty in the differencing disk BAT then this
+// method will query parent disk for the same block. This function return error if the block cannot be created
+// due to any read error.
+//
+func (f *DifferencingDiskBlockFactory) Create(blockIndex uint32) (*Block, error) {
+ if !f.params.BlockAllocationTable.HasData(blockIndex) {
+ if f.cachedBlock == nil || f.cachedBlock.BlockIndex != blockIndex {
+ var err error
+ f.cachedBlock, err = f.params.ParentBlockFactory.Create(blockIndex)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return f.cachedBlock, nil
+ }
+
+ if f.cachedBlock == nil || f.cachedBlock.BlockIndex != blockIndex {
+ logicalRange := common.NewIndexRangeFromLength(int64(blockIndex)*f.GetBlockSize(), f.GetBlockSize())
+ f.cachedBlock = &Block{
+ BlockIndex: blockIndex,
+ LogicalRange: logicalRange,
+ VhdUniqueID: f.params.VhdFooter.UniqueID,
+ IsEmpty: false,
+ BlockDataReader: f.blockDataReader,
+ }
+
+ var err error
+ f.cachedBlock.BitMap, err = f.bitmapFactory.Create(blockIndex)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return f.cachedBlock, nil
+}
+
+// GetSector returns an instance of Sector in a differencing disk, parameter block object identifies the block
+// containing the sector, the parameter sectorIndex identifies the sector in the block. If the sector to be
+// read is marked as empty in the block's bitmap then this method will query parent disk for the same sector.
+// This function return error if the sector cannot be created due to any read error or if the requested sector
+// index is invalid.
+//
+func (f *DifferencingDiskBlockFactory) GetSector(block *Block, sectorIndex uint32) (*Sector, error) {
+ blockIndex := block.BlockIndex
+ if block.IsEmpty {
+ return f.sectorFactory.CreateEmptySector(blockIndex, sectorIndex), nil
+ }
+
+ if block.BitMap != nil {
+ s, err := block.BitMap.Get(int32(sectorIndex))
+ if err != nil {
+ return nil, err
+ }
+
+ if s {
+ return f.sectorFactory.Create(block, sectorIndex)
+ }
+ }
+
+ blockInParentDisk, err := f.params.ParentBlockFactory.Create(blockIndex)
+ if err != nil {
+ return nil, err
+ }
+
+ return f.params.ParentBlockFactory.GetSector(blockInParentDisk, sectorIndex)
+}
+
+// GetBitmapFactory returns an instance of BitmapFactory that can be used to create the bitmap of a block
+// by reading block from differencing disk.
+//
+func (f *DifferencingDiskBlockFactory) GetBitmapFactory() *bitmap.Factory {
+ return f.bitmapFactory
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/differencingDiskBlockReader.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/differencingDiskBlockReader.go
new file mode 100644
index 00000000000..59cc7b62c2e
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/differencingDiskBlockReader.go
@@ -0,0 +1,61 @@
+package block
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/bat"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// DifferencingDiskBlockReader type satisfies BlockDataReader interface,
+// implementation of BlockDataReader::Read by this type can read the 'data' section
+// of a differencing disk's block.
+//
+type DifferencingDiskBlockReader struct {
+ vhdReader *reader.VhdReader
+ blockAllocationTable *bat.BlockAllocationTable
+ blockSizeInBytes uint32
+ emptyBlockData []byte
+}
+
+// NewDifferencingDiskBlockReader create a new instance of DifferencingDiskBlockReader which read
+// the 'data' section of differencing disk block.
+// The parameter vhdReader is the reader to read the disk
+// The parameter blockAllocationTable represents the disk's BAT
+// The parameter blockSizeInBytes is the size of the differencing disk block
+//
+func NewDifferencingDiskBlockReader(vhdReader *reader.VhdReader, blockAllocationTable *bat.BlockAllocationTable, blockSizeInBytes uint32) *DifferencingDiskBlockReader {
+ return &DifferencingDiskBlockReader{
+ vhdReader: vhdReader,
+ blockAllocationTable: blockAllocationTable,
+ blockSizeInBytes: blockSizeInBytes,
+ emptyBlockData: nil,
+ }
+}
+
+// Read reads the data in a block of a differencing disk
+// The parameter block represents the block whose 'data' section to read
+//
+func (r *DifferencingDiskBlockReader) Read(block *Block) ([]byte, error) {
+ blockIndex := block.BlockIndex
+ if !r.blockAllocationTable.HasData(blockIndex) {
+ if r.emptyBlockData == nil {
+ r.emptyBlockData = make([]byte, r.blockSizeInBytes)
+ }
+ return r.emptyBlockData, nil
+ }
+
+ blockDataBuffer := make([]byte, r.blockSizeInBytes)
+ index := 0
+ sectorCount := block.GetSectorCount()
+ for i := int64(0); i < sectorCount; i++ {
+ sector, err := block.GetSector(uint32(i))
+ if err != nil {
+ return nil, NewDataReadError(blockIndex, footer.DiskTypeDifferencing, err)
+ }
+
+ n := copy(blockDataBuffer[index:], sector.Data)
+ index += n
+ }
+
+ return blockDataBuffer, nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dynamicDiskBlockFactory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dynamicDiskBlockFactory.go
new file mode 100644
index 00000000000..92eee11f6ea
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dynamicDiskBlockFactory.go
@@ -0,0 +1,111 @@
+package block
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+)
+
+// DynamicDiskBlockFactory is a type which is used for following purposes
+// To create a Block instance representing a dynamic disk block
+// To get the number of blocks in the dynamic disk
+// To get the block size of the block in dynamic disk
+// To get a Sector instance representing sector of dynamic disk's block
+// To get the logical footer range of fixed disk generated from the dynamic disk
+//
+type DynamicDiskBlockFactory struct {
+ params *FactoryParams
+ bitmapFactory *bitmap.Factory
+ sectorFactory *SectorFactory
+ blockDataReader DataReader
+ cachedDynamicBlock *Block
+}
+
+// NewDynamicDiskFactory creates a DynamicDiskBlockFactory instance which can be used to create a
+// Block objects representing dynamic disk block of a size specified in header BlockSize field
+// parameter params contains header, footer, BAT of dynamic disk and reader to read the disk.
+//
+func NewDynamicDiskFactory(params *FactoryParams) *DynamicDiskBlockFactory {
+ blockFactory := &DynamicDiskBlockFactory{params: params}
+
+ blockFactory.bitmapFactory = bitmap.NewFactory(blockFactory.params.VhdReader,
+ blockFactory.params.BlockAllocationTable)
+
+ blockFactory.sectorFactory = NewSectorFactory(blockFactory.params.VhdReader,
+ blockFactory.params.BlockAllocationTable.HasData,
+ blockFactory.params.BlockAllocationTable.GetBlockDataAddress)
+
+ blockFactory.blockDataReader = NewDynamicDiskBlockReader(blockFactory.params.VhdReader,
+ blockFactory.params.BlockAllocationTable,
+ blockFactory.params.VhdHeader.BlockSize)
+ return blockFactory
+}
+
+// GetBlockCount returns the number of blocks in the dynamic disk.
+//
+func (f *DynamicDiskBlockFactory) GetBlockCount() int64 {
+ return int64(f.params.BlockAllocationTable.BATEntriesCount)
+}
+
+// GetBlockSize returns the size of the 'data section' of block in bytes in the dynamic disk.
+//
+func (f *DynamicDiskBlockFactory) GetBlockSize() int64 {
+ return int64(f.params.VhdHeader.BlockSize)
+}
+
+// GetFooterRange returns the logical range of the footer when converting this dynamic vhd to fixed
+// logical range of footer is the absolute start and end byte offset of the footer.
+//
+func (f *DynamicDiskBlockFactory) GetFooterRange() *common.IndexRange {
+ return common.NewIndexRangeFromLength(f.GetBlockCount()*f.GetBlockSize(), vhdcore.VhdFooterSize)
+}
+
+// Create returns an instance of Block which represents a dynamic disk block, the parameter blockIndex
+// identifies the block. This function return error if the block cannot be created due to any read error.
+//
+func (f *DynamicDiskBlockFactory) Create(blockIndex uint32) (*Block, error) {
+ if f.cachedDynamicBlock == nil || f.cachedDynamicBlock.BlockIndex != blockIndex {
+ logicalRange := common.NewIndexRangeFromLength(int64(blockIndex)*f.GetBlockSize(), f.GetBlockSize())
+ f.cachedDynamicBlock = &Block{
+ BlockIndex: blockIndex,
+ LogicalRange: logicalRange,
+ VhdUniqueID: f.params.VhdFooter.UniqueID,
+ BlockDataReader: f.blockDataReader,
+ }
+
+ if f.params.BlockAllocationTable.HasData(blockIndex) {
+ var err error
+ f.cachedDynamicBlock.BitMap, err = f.bitmapFactory.Create(blockIndex)
+ if err != nil {
+ return nil, err
+ }
+
+ f.cachedDynamicBlock.IsEmpty = false
+ } else {
+ f.cachedDynamicBlock.BitMap = nil
+ f.cachedDynamicBlock.IsEmpty = true
+ }
+ }
+
+ return f.cachedDynamicBlock, nil
+}
+
+// GetSector returns an instance of Sector in a dynamic disk, parameter block object identifying the block
+// containing the sector, the parameter sectorIndex identifies the sector in the block. This function return
+// error if the sector cannot be created due to any read error or if the requested sector index is invalid.
+//
+func (f *DynamicDiskBlockFactory) GetSector(block *Block, sectorIndex uint32) (*Sector, error) {
+ blockIndex := block.BlockIndex
+ if block.IsEmpty {
+ return f.sectorFactory.CreateEmptySector(blockIndex, sectorIndex), nil
+ }
+
+ return f.sectorFactory.Create(block, sectorIndex)
+}
+
+// GetBitmapFactory returns an instance of BitmapFactory that can be used to create the bitmap of a block
+// by reading block from dynamic disk.
+//
+func (f *DynamicDiskBlockFactory) GetBitmapFactory() *bitmap.Factory {
+ return f.bitmapFactory
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dynamicDiskBlockReader.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dynamicDiskBlockReader.go
new file mode 100644
index 00000000000..0a0e699d680
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/dynamicDiskBlockReader.go
@@ -0,0 +1,62 @@
+package block
+
+import (
+ "io"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/bat"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// DynamicDiskBlockReader type satisfies BlockDataReader interface,
+// implementation of BlockDataReader::Read by this type can read the 'data' section
+// of a dynamic disk's block.
+//
+type DynamicDiskBlockReader struct {
+ vhdReader *reader.VhdReader
+ blockAllocationTable *bat.BlockAllocationTable
+ blockSizeInBytes uint32
+ emptyBlockData []byte
+}
+
+// NewDynamicDiskBlockReader create a new instance of DynamicDiskBlockReader which read
+// the 'data' section of dynamic disk block.
+// The parameter vhdReader is the reader to read the disk
+// The parameter blockAllocationTable represents the disk's BAT
+// The parameter blockSizeInBytes is the size of the dynamic disk block
+//
+func NewDynamicDiskBlockReader(vhdReader *reader.VhdReader, blockAllocationTable *bat.BlockAllocationTable, blockSizeInBytes uint32) *DynamicDiskBlockReader {
+
+ return &DynamicDiskBlockReader{
+ vhdReader: vhdReader,
+ blockAllocationTable: blockAllocationTable,
+ blockSizeInBytes: blockSizeInBytes,
+ emptyBlockData: nil,
+ }
+}
+
+// Read reads the data in a block of a dynamic disk
+// The parameter block represents the block whose 'data' section to read
+//
+func (r *DynamicDiskBlockReader) Read(block *Block) ([]byte, error) {
+ blockIndex := block.BlockIndex
+ if !r.blockAllocationTable.HasData(blockIndex) {
+ if r.emptyBlockData == nil {
+ r.emptyBlockData = make([]byte, r.blockSizeInBytes)
+ }
+ return r.emptyBlockData, nil
+ }
+
+ blockDataByteOffset := r.blockAllocationTable.GetBlockDataAddress(blockIndex)
+ blockDataBuffer := make([]byte, r.blockSizeInBytes)
+ n, err := r.vhdReader.ReadBytes(blockDataByteOffset, blockDataBuffer)
+ if err == io.ErrUnexpectedEOF {
+ return blockDataBuffer[:n], nil
+ }
+
+ if err != nil {
+ return nil, NewDataReadError(blockIndex, footer.DiskTypeDynamic, err)
+ }
+
+ return blockDataBuffer, nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/factory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/factory.go
new file mode 100644
index 00000000000..cd3fe8dd1db
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/factory.go
@@ -0,0 +1,16 @@
+package block
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+)
+
+// Factory interface that all block factories specific to disk type (fixed,
+// dynamic, differencing) needs to satisfy.
+//
+type Factory interface {
+ GetBlockCount() int64
+ GetBlockSize() int64
+ Create(blockIndex uint32) (*Block, error)
+ GetFooterRange() *common.IndexRange
+ GetSector(block *Block, sectorIndex uint32) (*Sector, error)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/factoryParams.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/factoryParams.go
new file mode 100644
index 00000000000..0fb061200c7
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/factoryParams.go
@@ -0,0 +1,19 @@
+package block
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/bat"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/header"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// FactoryParams represents type of the parameter for different disk block
+// factories.
+//
+type FactoryParams struct {
+ VhdFooter *footer.Footer
+ VhdHeader *header.Header
+ BlockAllocationTable *bat.BlockAllocationTable
+ VhdReader *reader.VhdReader
+ ParentBlockFactory Factory
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/fixedDiskBlockFactory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/fixedDiskBlockFactory.go
new file mode 100644
index 00000000000..348953f3c1a
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/fixedDiskBlockFactory.go
@@ -0,0 +1,136 @@
+package block
+
+import (
+ "log"
+ "math"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+)
+
+// FixedDiskBlockFactory is a type which is used for following purposes
+// To create a Block instance representing a fixed disk block
+// To get the number of blocks in the fixed disk
+// To get the block size of the block in fixed disk
+// To get a Sector instance representing sector of fixed disk's block
+// To get the logical footer range of the fixed disk
+//
+type FixedDiskBlockFactory struct {
+ params *FactoryParams
+ sectorFactory *SectorFactory
+ blockDataReader DataReader
+ blockCount int64
+ blockSize int64
+ extraBlockIndex *int64
+ cachedFixedBlock *Block
+}
+
+// NewFixedDiskBlockFactoryWithDefaultBlockSize creates a FixedDiskBlockFactory instance which can
+// be used to create a Block object representing fixed disk block of default size 512 KB.
+// parameter params contains header, footer of the fixed disk and reader to read the disk.
+//
+func NewFixedDiskBlockFactoryWithDefaultBlockSize(params *FactoryParams) *FixedDiskBlockFactory {
+ return NewFixedDiskBlockFactory(params, vhdcore.VhdDefaultBlockSize)
+}
+
+// NewFixedDiskBlockFactory creates a FixedDiskBlockFactory instance which can be used to create a
+// Block objects representing fixed disk block of a specific size, parameter params contains header,
+// footer of the fixed disk and reader to read the disk, parameter blockSize represents the size
+// of blocks in the fixed disk
+//
+func NewFixedDiskBlockFactory(params *FactoryParams, blockSize int64) *FixedDiskBlockFactory {
+ blockFactory := &FixedDiskBlockFactory{params: params}
+
+ // VirtualSize is the current size of the fixed disk in bytes.
+ c := float64(blockFactory.params.VhdFooter.VirtualSize) / float64(blockSize)
+ cf := int64(math.Floor(c))
+ cc := int64(math.Ceil(c))
+ if cf < cc {
+ blockFactory.extraBlockIndex = &cf
+ } else {
+ blockFactory.extraBlockIndex = nil
+ }
+ blockFactory.blockCount = cc
+ blockFactory.blockSize = blockSize
+ blockFactory.sectorFactory = NewSectorFactory(blockFactory.params.VhdReader,
+ func(blockIndex uint32) bool {
+ return blockIndex != vhdcore.VhdNoDataInt
+ },
+ func(blockIndex uint32) int64 {
+ return int64(blockIndex) * blockSize
+ },
+ )
+ blockFactory.blockDataReader = NewFixedDiskBlockReader(blockFactory.params.VhdReader, uint32(blockSize))
+ return blockFactory
+}
+
+// GetBlockCount returns the number of blocks in the fixed disk.
+//
+func (f *FixedDiskBlockFactory) GetBlockCount() int64 {
+ return f.blockCount
+}
+
+// GetBlockSize returns the size of the block in bytes of the fixed disk.
+//
+func (f *FixedDiskBlockFactory) GetBlockSize() int64 {
+ return f.blockSize
+}
+
+// GetFooterRange returns the logical range of the footer of the fixed disk, logical range of footer
+// is the absolute start and end byte offset of the footer.
+//
+func (f *FixedDiskBlockFactory) GetFooterRange() *common.IndexRange {
+ footerStartIndex := f.params.VhdReader.Size - vhdcore.VhdFooterSize
+ return common.NewIndexRangeFromLength(footerStartIndex, vhdcore.VhdFooterSize)
+}
+
+// Create returns an instance of Block which represents a fixed disk block, the parameter blockIndex
+// identifies the block.
+//
+func (f *FixedDiskBlockFactory) Create(blockIndex uint32) (*Block, error) {
+ if f.cachedFixedBlock == nil || f.cachedFixedBlock.BlockIndex != blockIndex {
+ var logicalRange *common.IndexRange
+ if f.extraBlockIndex != nil && *f.extraBlockIndex == int64(blockIndex) {
+ logicalRange = f.getExtraBlockLogicalRange()
+ } else {
+ logicalRange = common.NewIndexRangeFromLength(int64(blockIndex)*f.blockSize, f.blockSize)
+ }
+
+ f.cachedFixedBlock = &Block{
+ BlockIndex: blockIndex,
+ LogicalRange: logicalRange,
+ VhdUniqueID: f.params.VhdFooter.UniqueID,
+ BitMap: nil, // Bitmap applies to dynamic and differentials disks
+ BlockDataReader: f.blockDataReader,
+ }
+
+ f.cachedFixedBlock.IsEmpty = blockIndex == vhdcore.VhdNoDataInt
+ }
+ return f.cachedFixedBlock, nil
+}
+
+// GetSector returns an instance of Sector in a fixed disk, parameter block describes the block containing the
+// sector, the parameter sectorIndex identifies the sector in the block. This function return error if the sector
+// cannot be created due to any read error or if the requested sector index is invalid.
+//
+func (f *FixedDiskBlockFactory) GetSector(block *Block, sectorIndex uint32) (*Sector, error) {
+ blockIndex := block.BlockIndex
+ if block.IsEmpty {
+ return f.sectorFactory.CreateEmptySector(blockIndex, sectorIndex), nil
+ }
+
+ return f.sectorFactory.Create(block, sectorIndex)
+}
+
+// getExtraBlockLogicalRange returns the IndexRange representing the additional block if any. Additional block
+// is the last block whose size < FixedDiskBlockFactory.BlockSize
+//
+func (f *FixedDiskBlockFactory) getExtraBlockLogicalRange() *common.IndexRange {
+ if f.extraBlockIndex == nil {
+ log.Panicf("Unexpected state, extraBlockIndex not set")
+ }
+
+ startIndex := *(f.extraBlockIndex) * f.blockSize
+ size := f.params.VhdReader.Size - startIndex - vhdcore.VhdFooterSize
+ return common.NewIndexRangeFromLength(startIndex, size)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/fixedDiskBlockReader.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/fixedDiskBlockReader.go
new file mode 100644
index 00000000000..cd28539966f
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/fixedDiskBlockReader.go
@@ -0,0 +1,47 @@
+package block
+
+import (
+ "io"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// FixedDiskBlockReader type satisfies BlockDataReader interface,
+// implementation of BlockDataReader::Read by this type can read the data from a block
+// of a fixed disk.
+//
+type FixedDiskBlockReader struct {
+ vhdReader *reader.VhdReader
+ blockSizeInBytes uint32
+}
+
+// NewFixedDiskBlockReader create a new instance of FixedDiskBlockReader which can read data from
+// a fixed disk block.
+// The parameter vhdReader is the reader to read the disk
+// The parameter blockSizeInBytes is the size of the fixed disk block
+//
+func NewFixedDiskBlockReader(vhdReader *reader.VhdReader, blockSizeInBytes uint32) *FixedDiskBlockReader {
+ return &FixedDiskBlockReader{
+ vhdReader: vhdReader,
+ blockSizeInBytes: blockSizeInBytes,
+ }
+}
+
+// Read reads the data in a block of a fixed disk
+// The parameter block represents the block to read
+//
+func (r *FixedDiskBlockReader) Read(block *Block) ([]byte, error) {
+ blockIndex := block.BlockIndex
+ blockByteOffset := int64(blockIndex) * int64(r.blockSizeInBytes)
+ blockDataBuffer := make([]byte, block.LogicalRange.Length())
+ n, err := r.vhdReader.ReadBytes(blockByteOffset, blockDataBuffer)
+ if err == io.ErrUnexpectedEOF {
+ return blockDataBuffer[:n], nil
+ }
+
+ if err != nil {
+ return nil, NewDataReadError(blockIndex, footer.DiskTypeFixed, err)
+ }
+ return blockDataBuffer, nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sector.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sector.go
new file mode 100644
index 00000000000..c9a7b1d32ea
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sector.go
@@ -0,0 +1,9 @@
+package block
+
+// Sector represents a sector in the 'data section' of a block.
+//
+type Sector struct {
+ BlockIndex uint32
+ SectorIndex int64
+ Data []byte
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sectorFactory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sectorFactory.go
new file mode 100644
index 00000000000..d0a5584160d
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sectorFactory.go
@@ -0,0 +1,74 @@
+package block
+
+import (
+ "fmt"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// SectorFactory type is used to create Sector instance by reading 512 byte sector from block's 'data section'.
+//
+type SectorFactory struct {
+ vhdReader *reader.VhdReader
+ blockHasData func(uint32) bool
+ getBlockAddress func(uint32) int64
+ emptySectorBuf []byte
+}
+
+// NewSectorFactory creates a new instance of SectorFactory, which can be used to create Sector instances
+// by reading 512 byte sector from block's 'data section'
+// vhdReader is the reader to be used to read the sector, blockHasData is a function which can be used to
+// check a block is empty by providing block identifier, getBlockAddress is a function which can be used
+// to fetch the absolute byte offset of a block by providing block identifier.
+//
+func NewSectorFactory(vhdReader *reader.VhdReader, blockHasData func(uint32) bool, getBlockAddress func(uint32) int64) *SectorFactory {
+ return &SectorFactory{
+ vhdReader: vhdReader,
+ blockHasData: blockHasData,
+ getBlockAddress: getBlockAddress,
+ }
+}
+
+// Create creates an instance of Sector by reading a 512 byte sector from the 'data section' of a block.
+// block describes the block containing the sector, sectorIndex identifies the sector to read.
+// This function return error if requested sector is invalid or in case of any read error.
+//
+func (f *SectorFactory) Create(block *Block, sectorIndex uint32) (*Sector, error) {
+ if int64(sectorIndex) > block.GetSectorCount() {
+ return nil, fmt.Errorf("Total sectors: %d, Requested Sectors: %d", block.GetSectorCount(), sectorIndex)
+ }
+
+ blockIndex := block.BlockIndex
+ if !f.blockHasData(blockIndex) {
+ return f.CreateEmptySector(blockIndex, sectorIndex), nil
+ }
+
+ blockDataSectionByteOffset := f.getBlockAddress(blockIndex)
+ sectorByteOffset := blockDataSectionByteOffset + vhdcore.VhdSectorLength*int64(sectorIndex)
+ sectorBuf := make([]byte, vhdcore.VhdSectorLength)
+ if _, err := f.vhdReader.ReadBytes(sectorByteOffset, sectorBuf); err != nil {
+ return nil, NewSectorReadError(blockIndex, sectorIndex, err)
+ }
+
+ return &Sector{
+ BlockIndex: blockIndex,
+ SectorIndex: int64(sectorIndex),
+ Data: sectorBuf,
+ }, nil
+}
+
+// CreateEmptySector creates an instance of Sector representing empty sector. The Data property of this sector
+// will be a slice of 512 bytes filled with zeros.
+//
+func (f *SectorFactory) CreateEmptySector(blockIndex, sectorIndex uint32) *Sector {
+ if f.emptySectorBuf == nil {
+ f.emptySectorBuf = make([]byte, vhdcore.VhdSectorLength)
+ }
+
+ return &Sector{
+ BlockIndex: blockIndex,
+ SectorIndex: int64(sectorIndex),
+ Data: f.emptySectorBuf,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sectorReadError.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sectorReadError.go
new file mode 100644
index 00000000000..79b6e469840
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/block/sectorReadError.go
@@ -0,0 +1,30 @@
+package block
+
+import "fmt"
+
+// SectorReadError is the error type representing block's sector read error.
+//
+type SectorReadError struct {
+ BlockIndex uint32
+ SectorIndex uint32
+ err error
+}
+
+// Error returns the string representation of the SectorReadError instance.
+//
+func (e *SectorReadError) Error() string {
+ return fmt.Sprintf("Read sector '%d' of block '%d' failed: %s", e.SectorIndex, e.BlockIndex, e.err)
+}
+
+// NewSectorReadError returns a new SectorReadError instance.
+// The parameter blockIndex represents index of the block
+// The parameter sectorIndex represents index of the sector within the block
+// The parameter err is the underlying read error.
+//
+func NewSectorReadError(blockIndex, sectorIndex uint32, err error) error {
+ return &SectorReadError{
+ BlockIndex: blockIndex,
+ SectorIndex: sectorIndex,
+ err: err,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/indexRange.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/indexRange.go
new file mode 100644
index 00000000000..8fe2957aaa5
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/indexRange.go
@@ -0,0 +1,383 @@
+package common
+
+import (
+ "fmt"
+ "sort"
+)
+
+// IndexRange represents sequence of integral numbers in a specified range, where range starts
+// at Start and ends at End, inclusive
+//
+type IndexRange struct {
+ Start int64
+ End int64
+}
+
+// NewIndexRange creates a new range with start as value of the first integer in the sequence
+// and end as value of last integer in the sequence.
+//
+func NewIndexRange(start, end int64) *IndexRange {
+ return &IndexRange{Start: start, End: end}
+}
+
+// NewIndexRangeFromLength creates a new range starting from start and ends at start + length - 1.
+//
+func NewIndexRangeFromLength(start, length int64) *IndexRange {
+ return NewIndexRange(start, start+length-1)
+}
+
+// TotalRangeLength returns the total length of a given slice of ranges.
+//
+func TotalRangeLength(ranges []*IndexRange) int64 {
+ var length = int64(0)
+ for _, r := range ranges {
+ length += r.Length()
+ }
+ return length
+}
+
+// SubtractRanges produces a set of ranges, each subset of ranges in this set is produced by
+// subtracting subtrahends from each range in minuends.
+//
+func SubtractRanges(minuends, subtrahends []*IndexRange) []*IndexRange {
+ var result = make([]*IndexRange, 0)
+ for _, minuend := range minuends {
+ result = minuend.SubtractRanges(subtrahends, false, result)
+ }
+
+ return sortAndDedup(result)
+}
+
+// ChunkRangesBySize produces a set of ranges by partitioning the ranges in the given ranges by
+// the given partition-size.
+// Each each range in the given ranges X will be partitioned by the given partition-size to produce
+// a range set A. If the last range in A is not of partition-size and if it is adjacent to the
+// next range in the X then we calculate the bytes required to reach partition-size and
+// 1. if next range has more bytes than required, then we borrow the required bytes from next
+// range and advances the next range start
+// 2. if next range has less or equal to the required bytes, then we borrow available and skip
+// next range
+//
+func ChunkRangesBySize(ranges []*IndexRange, chunkSizeInBytes int64) []*IndexRange {
+ var chunks = make([]*IndexRange, 0)
+ length := len(ranges)
+ var remaining *IndexRange
+
+ for i, current := range ranges {
+ if remaining != nil {
+ if remaining.Adjacent(current) {
+ requiredBytes := chunkSizeInBytes - remaining.Length()
+ availableBytes := current.Length()
+ if requiredBytes < availableBytes {
+ remaining.End += requiredBytes
+ current.Start += requiredBytes
+ chunks = append(chunks, remaining)
+ remaining = nil
+ } else {
+ remaining.End += availableBytes
+ current = nil
+ }
+ } else {
+ chunks = append(chunks, remaining)
+ remaining = nil
+ }
+ }
+
+ if current != nil {
+ chunksSet := current.PartitionBy(chunkSizeInBytes)
+
+ lastChunkIndex := len(chunksSet) - 1
+ lastChunk := chunksSet[lastChunkIndex]
+ if (lastChunk.Length() != chunkSizeInBytes) && (i+1 < length) && lastChunk.Adjacent(ranges[i+1]) {
+ remaining = lastChunk
+ chunks = append(chunks, chunksSet[:lastChunkIndex]...)
+ } else {
+ chunks = append(chunks, chunksSet...)
+ }
+ }
+ }
+
+ if remaining != nil {
+ chunks = append(chunks, remaining)
+ }
+
+ return chunks
+}
+
+// Length returns number of sequential integers in the range.
+//
+func (ir *IndexRange) Length() int64 {
+ return ir.End - ir.Start + 1
+}
+
+// Equals returns true if this and given range represents the same sequence, two sequences
+// are same if both have the same start and end.
+//
+func (ir *IndexRange) Equals(other *IndexRange) bool {
+ return other != nil && ir.Start == other.Start && ir.End == other.End
+}
+
+// CompareTo indicates whether the this range precedes, follows, or occurs in the same
+// position in the sort order as the other
+// A return value
+// Less than zero: This range precedes the other in the sort order, range A precedes
+// range B if A start before B or both has the same start and A ends
+// before B.
+// Zero: This range occurs in the same position as other in sort order, two
+// ranges are in the same sort position if both has the same start
+// and end
+// Greater than zero: This range follows the other in the sort order, a range A follows
+// range B, if A start after B or both has the same start and A ends
+// after B
+//
+func (ir *IndexRange) CompareTo(other *IndexRange) int64 {
+ r := ir.Start - other.Start
+ if r != 0 {
+ return r
+ }
+
+ return ir.End - other.End
+}
+
+// Intersects checks this and other range intersects, two ranges A and B intersects if either
+// of them starts or ends within the range of other, inclusive.
+//
+func (ir *IndexRange) Intersects(other *IndexRange) bool {
+ start := ir.Start
+ if start < other.Start {
+ start = other.Start
+ }
+
+ end := ir.End
+ if end > other.End {
+ end = other.End
+ }
+
+ return start <= end
+}
+
+// Intersection computes the range representing the intersection of two ranges, a return
+// value nil indicates the ranges does not intersects.
+//
+func (ir *IndexRange) Intersection(other *IndexRange) *IndexRange {
+ start := ir.Start
+ if start < other.Start {
+ start = other.Start
+ }
+
+ end := ir.End
+ if end > other.End {
+ end = other.End
+ }
+
+ if start > end {
+ return nil
+ }
+
+ return NewIndexRange(start, end)
+}
+
+// Includes checks this range includes the other range, a range A includes range B if B starts
+// and ends within A, inclusive. In other words a range A includes range B if their intersection
+// produces B
+//
+func (ir *IndexRange) Includes(other *IndexRange) bool {
+ if other.Start < ir.Start {
+ return false
+ }
+
+ if other.End > ir.End {
+ return false
+ }
+
+ return true
+}
+
+// Gap compute the range representing the gap between this and the other range, a return value
+// nil indicates there is no gap because either the ranges intersects or they are adjacent.
+//
+func (ir *IndexRange) Gap(other *IndexRange) *IndexRange {
+ if ir.Intersects(other) {
+ return nil
+ }
+
+ r := ir.CompareTo(other)
+ if r < 0 {
+ g := NewIndexRange(ir.End+1, other.Start-1)
+ if g.Length() <= 0 {
+ return nil
+ }
+ return g
+ }
+
+ g := NewIndexRange(other.End+1, ir.Start-1)
+ if g.Length() <= 0 {
+ return nil
+ }
+ return g
+}
+
+// Adjacent checks this range starts immediately starts after the other range or vice-versa,
+// a return value nil indicates the ranges intersects or there is a gap between the ranges.
+//
+func (ir *IndexRange) Adjacent(other *IndexRange) bool {
+ return !ir.Intersects(other) && ir.Gap(other) == nil
+}
+
+// Subtract subtracts other range from this range and appends the ranges representing the
+// differences to result slice.
+//
+// Given two ranges A and B, A - B produces
+// 1. No result
+// a. If they are equal or
+// b. B includes A i.e 'A n B' = A
+// OR
+// 2. A, if they don't intersects
+// OR
+// 3. [(A n B).End + 1, A.End], if A and 'A n B' has same start
+// OR
+// 4. [A.Start, (A n B).Start - 1], if A and 'A n B' has same end
+// OR
+// 5. { [A.Start, (A n B).Start - 1], [(A n B).End + 1, A.End] }, otherwise
+//
+func (ir *IndexRange) Subtract(other *IndexRange, result []*IndexRange) []*IndexRange {
+ if ir.Equals(other) {
+ return result
+ }
+
+ if !ir.Intersects(other) {
+ result = append(result, NewIndexRange(ir.Start, ir.End))
+ return result
+ }
+
+ in := ir.Intersection(other)
+ if ir.Equals(in) {
+ return result
+ }
+
+ if in.Start == ir.Start {
+ result = append(result, NewIndexRange(in.End+1, ir.End))
+ return result
+ }
+
+ if in.End == ir.End {
+ result = append(result, NewIndexRange(ir.Start, in.Start-1))
+ return result
+ }
+
+ result = append(result, NewIndexRange(ir.Start, in.Start-1))
+ result = append(result, NewIndexRange(in.End+1, ir.End))
+ return result
+}
+
+// SubtractRanges subtracts a set of ranges from this range and appends the ranges representing
+// the differences to result slice. The result slice will be sorted and de-duped if sortandDedup
+// is true.
+//
+func (ir *IndexRange) SubtractRanges(ranges []*IndexRange, sortandDedup bool, result []*IndexRange) []*IndexRange {
+ intersectAny := false
+ for _, o := range ranges {
+ if ir.Intersects(o) {
+ result = ir.Subtract(o, result)
+ intersectAny = true
+ }
+ }
+
+ if !intersectAny {
+ result = append(result, NewIndexRange(ir.Start, ir.End))
+ }
+
+ if !sortandDedup {
+ return result
+ }
+
+ return sortAndDedup(result)
+}
+
+// Merge produces a range by merging this and other range if they are adjacent. Trying to merge
+// non-adjacent ranges are panic.
+//
+func (ir *IndexRange) Merge(other *IndexRange) *IndexRange {
+ if !ir.Adjacent(other) {
+ // TODO: error
+ }
+
+ if ir.CompareTo(other) < 0 {
+ return NewIndexRange(ir.Start, other.End)
+ }
+
+ return NewIndexRange(other.Start, ir.End)
+}
+
+// PartitionBy produces a slice of adjacent ranges of same size, first range in the slice starts
+// where this range starts and last range ends where this range ends. The length of last range will
+// be less than size if length of this range is not multiple of size.
+//
+func (ir *IndexRange) PartitionBy(size int64) []*IndexRange {
+ length := ir.Length()
+ if length <= size {
+ return []*IndexRange{NewIndexRange(ir.Start, ir.End)}
+ }
+
+ blocks := length / size
+ r := make([]*IndexRange, blocks+1)
+ for i := int64(0); i < blocks; i++ {
+ r[i] = NewIndexRangeFromLength(ir.Start+i*size, size)
+ }
+
+ reminder := length % size
+ if reminder != 0 {
+ r[blocks] = NewIndexRangeFromLength(ir.Start+blocks*size, reminder)
+ return r
+ }
+
+ return r[:blocks]
+}
+
+// String returns the string representation of this range, this satisfies stringer interface.
+//
+func (ir *IndexRange) String() string {
+ return fmt.Sprintf("{%d, %d}", ir.Start, ir.End)
+}
+
+// sortAndDedup sorts the given range slice in place, remove the duplicates from the sorted slice
+// and returns the updated slice.
+//
+func sortAndDedup(indexRanges []*IndexRange) []*IndexRange {
+ if len(indexRanges) == 0 {
+ return indexRanges
+ }
+ sort.Sort(indexRangeSorter(indexRanges))
+ i := 0
+ for j := 1; j < len(indexRanges); j++ {
+ if !indexRanges[i].Equals(indexRanges[j]) {
+ i++
+ indexRanges[i] = indexRanges[j]
+ }
+ }
+ return indexRanges[:i+1]
+}
+
+// indexRangeSorter is a type that satisfies sort.Interface interface for supporting sorting of
+// a IndexRange collection.
+//
+type indexRangeSorter []*IndexRange
+
+// Len is the number of elements in the range collection.
+//
+func (s indexRangeSorter) Len() int {
+ return len(s)
+}
+
+// Less reports whether range at i-th position precedes the range at j-th position in sort order.
+// range A precedes range B if A start before B or both has the same start and A ends before B.
+//
+func (s indexRangeSorter) Less(i, j int) bool {
+ return s[i].CompareTo(s[j]) < 0
+}
+
+// Swap swaps the elements with indexes i and j.
+//
+func (s indexRangeSorter) Swap(i, j int) {
+ s[i], s[j] = s[j], s[i]
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/utils.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/utils.go
new file mode 100644
index 00000000000..0955395899c
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/utils.go
@@ -0,0 +1,50 @@
+package common
+
+import (
+ "encoding/binary"
+ "unicode/utf16"
+ "unicode/utf8"
+)
+
+// Utf16BytesToStringLE decode the given UTF16 encoded byte sequence and returns
+// Go UTF8 encoded string, the byte order of the given sequence is little-endian.
+//
+func Utf16BytesToStringLE(b []byte) string {
+ return Utf16BytesToString(b, binary.LittleEndian)
+}
+
+// Utf16BytesToStringBE decode the given UTF16 encoded byte sequence and returns
+// Go UTF8 encoded string, the byte order of the given sequence is big-endian.
+//
+func Utf16BytesToStringBE(b []byte) string {
+ return Utf16BytesToString(b, binary.BigEndian)
+}
+
+// Utf16BytesToString decode the given UTF16 encoded byte sequence and returns
+// Go UTF8 encoded string, the byte order of the sequence is determined by the
+// given binary.ByteOrder parameter.
+//
+func Utf16BytesToString(b []byte, o binary.ByteOrder) string {
+ var u []uint16
+ l := len(b)
+ if l&1 == 0 {
+ u = make([]uint16, l>>1)
+ } else {
+ u = make([]uint16, l>>1+1)
+ u[len(u)-1] = utf8.RuneError
+ }
+
+ for i, j := 0, 0; j+1 < l; i, j = i+1, j+2 {
+ u[i] = o.Uint16(b[j:])
+ }
+
+ return string(utf16.Decode(u))
+}
+
+// CreateByteSliceCopy creates and returns a copy of the given slice.
+//
+func CreateByteSliceCopy(b []byte) []byte {
+ r := make([]byte, len(b))
+ copy(r, b)
+ return r
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/uuid.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/uuid.go
new file mode 100644
index 00000000000..d47bb9eb74d
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/common/uuid.go
@@ -0,0 +1,53 @@
+package common
+
+import (
+ "errors"
+ "fmt"
+)
+
+// UUID represents a Universally Unique Identifier.
+//
+type UUID struct {
+ uuid [16]byte
+}
+
+// NewUUID creates a new UUID, it uses the given 128-bit (16 byte) value as the uuid.
+//
+func NewUUID(b []byte) (*UUID, error) {
+ if len(b) != 16 {
+ return nil, errors.New("NewUUID: buffer requires to be 16 bytes")
+ }
+
+ u := &UUID{}
+ copy(u.uuid[:], b)
+ return u, nil
+}
+
+// String returns the string representation of the UUID which is 16 hex digits separated by hyphens
+// int form xxxx-xx-xx-xx-xxxxxx
+//
+func (u *UUID) String() string {
+ a := uint32(u.uuid[3])<<24 | uint32(u.uuid[2])<<16 | uint32(u.uuid[1])<<8 | uint32(u.uuid[0])
+ // a := b.order.Uint32(b.buffer[:4])
+ b1 := int16(int32(u.uuid[5])<<8 | int32(u.uuid[4]))
+ // b1 := b.order.Uint16(b.buffer[4:6])
+ c := int16(int32(u.uuid[7])<<8 | int32(u.uuid[6]))
+ // c := b.order.Uint16(b.buffer[6:8])
+ d := u.uuid[8]
+ e := u.uuid[9]
+ f := u.uuid[10]
+ g := u.uuid[11]
+ h := u.uuid[12]
+ i := u.uuid[13]
+ j := u.uuid[14]
+ k := u.uuid[15]
+ return fmt.Sprintf("%x-%x-%x-%x%x-%x%x%x%x%x%x", a, b1, c, d, e, f, g, h, i, j, k)
+}
+
+// ToByteSlice returns the UUID as byte slice.
+//
+func (u *UUID) ToByteSlice() []byte {
+ b := make([]byte, 16)
+ copy(b, u.uuid[:])
+ return b
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/constants.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/constants.go
new file mode 100644
index 00000000000..24b42f48ac0
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/constants.go
@@ -0,0 +1,29 @@
+package vhdcore
+
+// VhdDefaultBlockSize is the default block size of the VHD.
+//
+const VhdDefaultBlockSize int64 = 512 * 1024
+
+// VhdNoDataLong is the value in the BAT indicating a block is empty.
+//
+const VhdNoDataLong int64 = ^int64(0)
+
+// VhdNoDataInt is the value in the BAT indicating a block is empty.
+//
+const VhdNoDataInt uint32 = 0xFFFFFFFF
+
+// VhdPageSize is the size of the VHD page size.
+//
+const VhdPageSize int64 = 512
+
+// VhdFooterSize is the size of the VHD footer in bytes.
+//
+const VhdFooterSize int64 = 512
+
+// VhdSectorLength is the sector length which is always 512 bytes, as per VHD specification.
+//
+const VhdSectorLength int64 = 512
+
+// VhdFooterChecksumOffset is the bye offset of checksum field in the VHD footer.
+//
+const VhdFooterChecksumOffset int = 64
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream/diskstream.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream/diskstream.go
new file mode 100644
index 00000000000..de2e697e953
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream/diskstream.go
@@ -0,0 +1,284 @@
+package diskstream
+
+import (
+ "errors"
+ "io"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/block"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile"
+)
+
+// DiskStream provides a logical stream over a VHD file.
+// The type exposes the VHD as a fixed VHD, regardless of actual underlying VHD type (dynamic, differencing
+// or fixed type)
+//
+type DiskStream struct {
+ offset int64
+ size int64
+ isClosed bool
+ vhdFactory *vhdfile.FileFactory
+ vhdFile *vhdfile.VhdFile
+ vhdBlockFactory block.Factory
+ vhdFooterRange *common.IndexRange
+ vhdDataRange *common.IndexRange
+}
+
+// StreamExtent describes a block range of a disk which contains data.
+//
+type StreamExtent struct {
+ Range *common.IndexRange
+ OwnerVhdUniqueID *common.UUID
+}
+
+// CreateNewDiskStream creates a new DiskStream.
+// Parameter vhdPath is the path to VHD
+//
+func CreateNewDiskStream(vhdPath string) (*DiskStream, error) {
+ var err error
+ stream := &DiskStream{offset: 0, isClosed: false}
+ stream.vhdFactory = &vhdfile.FileFactory{}
+ if stream.vhdFile, err = stream.vhdFactory.Create(vhdPath); err != nil {
+ return nil, err
+ }
+
+ if stream.vhdBlockFactory, err = stream.vhdFile.GetBlockFactory(); err != nil {
+ return nil, err
+ }
+
+ stream.vhdFooterRange = stream.vhdBlockFactory.GetFooterRange()
+ stream.size = stream.vhdFooterRange.End + 1
+ stream.vhdDataRange = common.NewIndexRangeFromLength(0, stream.size-stream.vhdFooterRange.Length())
+ return stream, nil
+}
+
+// GetDiskType returns the type of the disk, expected values are DiskTypeFixed, DiskTypeDynamic
+// or DiskTypeDifferencing
+//
+func (s *DiskStream) GetDiskType() footer.DiskType {
+ return s.vhdFile.GetDiskType()
+}
+
+// GetSize returns the length of the stream in bytes.
+//
+func (s *DiskStream) GetSize() int64 {
+ return s.size
+}
+
+// Read reads up to len(b) bytes from the Vhd file. It returns the number of bytes read and an error,
+// if any. EOF is signaled when no more data to read and n will set to 0.
+//
+// If the internal read offset is a byte offset in the data segment of the VHD and If reader reaches
+// end of data section after reading some but not all the bytes then Read won't read from the footer
+// section, the next Read will read from the footer.
+//
+// If the internal read offset is a byte offset in the footer segment of the VHD and if reader reaches
+// end of footer section after reading some but not all the bytes then Read won't return any error.
+//
+// Read satisfies io.Reader interface
+//
+func (s *DiskStream) Read(p []byte) (n int, err error) {
+ if s.offset >= s.size {
+ return 0, io.EOF
+ }
+
+ count := len(p)
+ if count == 0 {
+ return 0, nil
+ }
+
+ rangeToRead := common.NewIndexRangeFromLength(s.offset, int64(count))
+ if s.vhdDataRange.Intersects(rangeToRead) {
+ writtenCount, err := s.readFromBlocks(rangeToRead, p)
+ s.offset += int64(writtenCount)
+ return writtenCount, err
+ }
+
+ if s.vhdFooterRange.Intersects(rangeToRead) {
+ writtenCount, err := s.readFromFooter(rangeToRead, p)
+ s.offset += int64(writtenCount)
+ return writtenCount, err
+ }
+
+ return 0, nil
+}
+
+// Seek sets the offset for the next Read on the stream to offset, interpreted according to whence:
+// 0 means relative to the origin of the stream, 1 means relative to the current offset, and 2
+// means relative to the end. It returns the new offset and an error, if any.
+//
+// Seek satisfies io.Seeker interface
+//
+func (s *DiskStream) Seek(offset int64, whence int) (int64, error) {
+ switch whence {
+ default:
+ return 0, errors.New("Seek: invalid whence")
+ case 0:
+ offset += 0
+ case 1:
+ offset += s.offset
+ case 2:
+ offset += s.size - 1
+ }
+
+ if offset < 0 || offset >= s.size {
+ return 0, errors.New("Seek: invalid offset")
+ }
+
+ s.offset = offset
+ return offset, nil
+}
+
+// Close closes the VHD file, rendering it unusable for I/O. It returns an error, if any.
+//
+// Close satisfies io.Closer interface
+//
+func (s *DiskStream) Close() error {
+ if !s.isClosed {
+ s.vhdFactory.Dispose(nil)
+ s.isClosed = true
+ }
+
+ return nil
+}
+
+// GetExtents gets the extents of the stream that contain non-zero data. Each extent describes a block's data
+// section range which contains data.
+// For dynamic or differencing disk - a block is empty if the BAT corresponding to the block contains 0xFFFFFFFF
+// so returned extents slice will not contain such range.
+// For fixed disk - this method returns extents describing ranges of all blocks, to rule out fixed disk block
+// ranges containing zero bytes use DetectEmptyRanges function in upload package.
+//
+func (s *DiskStream) GetExtents() ([]*StreamExtent, error) {
+ extents := make([]*StreamExtent, 1)
+ blocksCount := s.vhdBlockFactory.GetBlockCount()
+ for i := int64(0); i < blocksCount; i++ {
+ currentBlock, err := s.vhdBlockFactory.Create(uint32(i))
+ if err != nil {
+ return nil, err
+ }
+ if !currentBlock.IsEmpty {
+ extents = append(extents, &StreamExtent{
+ Range: currentBlock.LogicalRange,
+ OwnerVhdUniqueID: currentBlock.VhdUniqueID,
+ })
+ }
+ }
+ extents = append(extents, &StreamExtent{
+ Range: s.vhdFooterRange,
+ OwnerVhdUniqueID: s.vhdFile.Footer.UniqueID,
+ })
+
+ return extents, nil
+}
+
+// EnumerateExtents iterate through the extents of the stream that contain non-zero data and invokes the function
+// identified by the parameter f for each extent. Each extent describes a block's data section range which
+// contains data.
+// For dynamic or differencing disk - a block is empty if the BAT corresponding to the block contains 0xFFFFFFFF
+// so returned extents slice will not contain such range.
+// For fixed disk - this method returns extents describing ranges of all blocks, to rule out fixed disk block
+// ranges containing zero bytes use DetectEmptyRanges function in upload package.
+//
+func (s *DiskStream) EnumerateExtents(f func(*StreamExtent, error) bool) {
+ blocksCount := s.vhdBlockFactory.GetBlockCount()
+ i := int64(0)
+ for ; i < blocksCount; i++ {
+ if currentBlock, err := s.vhdBlockFactory.Create(uint32(i)); err != nil {
+ continueEnumerate := f(nil, err)
+ if !continueEnumerate {
+ break
+ }
+ } else {
+ if !currentBlock.IsEmpty {
+ continueEnumerate := f(&StreamExtent{
+ Range: currentBlock.LogicalRange,
+ OwnerVhdUniqueID: currentBlock.VhdUniqueID,
+ }, nil)
+ if !continueEnumerate {
+ break
+ }
+ }
+ }
+ }
+ if i == blocksCount {
+ f(&StreamExtent{
+ Range: s.vhdFooterRange,
+ OwnerVhdUniqueID: s.vhdFile.Footer.UniqueID,
+ }, nil)
+ }
+}
+
+// readFromBlocks identifies the blocks constituting the range rangeToRead, and read data from these
+// blocks into p. It returns the number of bytes read, which will be the minimum of sum of lengths
+// of all constituting range and len(p), provided there is no error.
+//
+func (s *DiskStream) readFromBlocks(rangeToRead *common.IndexRange, p []byte) (n int, err error) {
+ rangeToReadFromBlocks := s.vhdDataRange.Intersection(rangeToRead)
+ if rangeToReadFromBlocks == nil {
+ return 0, nil
+ }
+
+ writtenCount := 0
+ maxCount := len(p)
+ blockSize := s.vhdBlockFactory.GetBlockSize()
+ startingBlock := s.byteToBlock(rangeToReadFromBlocks.Start)
+ endingBlock := s.byteToBlock(rangeToReadFromBlocks.End)
+
+ for blockIndex := startingBlock; blockIndex <= endingBlock && writtenCount < maxCount; blockIndex++ {
+ currentBlock, err := s.vhdBlockFactory.Create(uint32(blockIndex))
+ if err != nil {
+ return writtenCount, err
+ }
+
+ blockData, err := currentBlock.Data()
+ if err != nil {
+ return writtenCount, err
+ }
+
+ rangeToReadInBlock := currentBlock.LogicalRange.Intersection(rangeToReadFromBlocks)
+ copyStartIndex := rangeToReadInBlock.Start % blockSize
+ writtenCount += copy(p[writtenCount:], blockData[copyStartIndex:(copyStartIndex+rangeToReadInBlock.Length())])
+ }
+
+ return writtenCount, nil
+}
+
+// readFromFooter reads the range rangeToRead from footer into p. It returns the number of bytes read, which
+// will be minimum of the given range length and len(p), provided there is no error.
+//
+func (s *DiskStream) readFromFooter(rangeToRead *common.IndexRange, p []byte) (n int, err error) {
+ rangeToReadFromFooter := s.vhdFooterRange.Intersection(rangeToRead)
+ if rangeToReadFromFooter == nil {
+ return 0, nil
+ }
+
+ vhdFooter := s.vhdFile.Footer.CreateCopy()
+ if vhdFooter.DiskType != footer.DiskTypeFixed {
+ vhdFooter.DiskType = footer.DiskTypeFixed
+ vhdFooter.HeaderOffset = vhdcore.VhdNoDataLong
+ vhdFooter.CreatorApplication = "wa"
+ }
+ // As per VHD spec, the size reported by the footer should same as 'header.MaxTableEntries * header.BlockSize'
+ // But the VHD created by some tool (e.g. qemu) are not honoring this. Azure will reject the VHD if the size
+ // specified in the footer of VHD not match 'VHD blob size - VHD Footer Size'
+ //
+ vhdFooter.PhysicalSize = s.GetSize() - vhdcore.VhdFooterSize
+ vhdFooter.VirtualSize = s.GetSize() - vhdcore.VhdFooterSize
+
+ // Calculate the checksum and serialize the footer
+ //
+ vhdFooterBytes := footer.SerializeFooter(vhdFooter)
+ copyStartIndex := rangeToReadFromFooter.Start - s.vhdFooterRange.Start
+ writtenCount := copy(p, vhdFooterBytes[copyStartIndex:copyStartIndex+rangeToReadFromFooter.Length()])
+ return writtenCount, nil
+}
+
+// byteToBlock returns the block index corresponding to the given byte position.
+//
+func (s *DiskStream) byteToBlock(position int64) int64 {
+ sectorsPerBlock := s.vhdBlockFactory.GetBlockSize() / vhdcore.VhdSectorLength
+ return position / vhdcore.VhdSectorLength / sectorsPerBlock
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/diskGeometry.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/diskGeometry.go
new file mode 100644
index 00000000000..92174b48c0d
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/diskGeometry.go
@@ -0,0 +1,104 @@
+package footer
+
+import (
+ "fmt"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+)
+
+// DiskGeometry represents the cylinder, heads and sectors (CHS) per track.
+//
+type DiskGeometry struct {
+ // Offset = 0, Size = 2
+ // Stored in big-endian format
+ Cylinder uint16
+ // Offset = 2, Size = 1
+ Heads byte
+ // Offset = 3, Size = 1
+ Sectors byte
+}
+
+// CreateNewDiskGeometry creates a new DiskGeometry from the given virtual
+// size. CHS field values are calculated based on the total data sectors
+// present in the disk image.
+//
+func CreateNewDiskGeometry(virtualSize int64) *DiskGeometry {
+ // Total data sectors present in the disk image
+ var totalSectors = virtualSize / vhdcore.VhdSectorLength
+ // Sectors per track on the disk
+ var sectorsPerTrack int64
+ // Number of heads present on the disk
+ var heads int32
+ // Cylinders * heads
+ var cylinderTimesHeads int64
+
+ // C * H * S
+ if totalSectors > 65535*16*255 {
+ totalSectors = 65535 * 16 * 255
+ }
+
+ if totalSectors >= 65535*16*63 {
+ sectorsPerTrack = 255
+ cylinderTimesHeads = totalSectors / sectorsPerTrack
+ heads = 16
+
+ return &DiskGeometry{
+ Cylinder: uint16(cylinderTimesHeads / int64(heads)),
+ Heads: byte(heads),
+ Sectors: byte(sectorsPerTrack),
+ }
+ }
+
+ sectorsPerTrack = 17
+ cylinderTimesHeads = totalSectors / sectorsPerTrack
+ heads = int32((cylinderTimesHeads + 1023) / 1024)
+
+ if heads < 4 {
+ heads = 4
+ }
+
+ if cylinderTimesHeads >= int64(heads*1024) || heads > 16 {
+ sectorsPerTrack = 31
+ heads = 16
+ cylinderTimesHeads = totalSectors / sectorsPerTrack
+ }
+
+ if cylinderTimesHeads >= int64(heads*1024) {
+ sectorsPerTrack = 63
+ heads = 16
+ cylinderTimesHeads = totalSectors / sectorsPerTrack
+ }
+
+ return &DiskGeometry{
+ Cylinder: uint16(cylinderTimesHeads / int64(heads)),
+ Heads: byte(heads),
+ Sectors: byte(sectorsPerTrack),
+ }
+}
+
+// CreateCopy creates a copy of this instance
+//
+func (d *DiskGeometry) CreateCopy() *DiskGeometry {
+ return &DiskGeometry{
+ Cylinder: d.Cylinder,
+ Heads: d.Heads,
+ Sectors: d.Sectors,
+ }
+}
+
+// Equals returns true if this and other points to the same instance
+// or if CHS fields of pointed instances are same
+//
+func (d *DiskGeometry) Equals(other *DiskGeometry) bool {
+ if other == nil {
+ return false
+ }
+
+ return other == d || *other == *d
+}
+
+// String returns the string representation of this range, this satisfies stringer interface.
+//
+func (d *DiskGeometry) String() string {
+ return fmt.Sprintf("Cylinder:%d Heads:%d Sectors:%d", d.Cylinder, d.Heads, d.Sectors)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/diskType.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/diskType.go
new file mode 100644
index 00000000000..99ba271fa01
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/diskType.go
@@ -0,0 +1,38 @@
+package footer
+
+// DiskType type represents the type of the disk, Value is stored in the footer
+// in big-endian format.
+//
+type DiskType uint32
+
+const (
+ // DiskTypeNone represents a nil disk type
+ //
+ DiskTypeNone DiskType = 0
+ // DiskTypeFixed represents a fixed disk type
+ //
+ DiskTypeFixed DiskType = 2
+ // DiskTypeDynamic represents a dynamic disk type
+ //
+ DiskTypeDynamic DiskType = 3
+ // DiskTypeDifferencing represents a differencing disk type
+ //
+ DiskTypeDifferencing DiskType = 4
+)
+
+// String returns the string representation of the DiskType. If the int type value
+// does not match with the predefined disk types then this function return the
+// string "UnknownDiskType"
+//
+func (d DiskType) String() string {
+ switch d {
+ case DiskTypeFixed:
+ return "Fixed"
+ case DiskTypeDynamic:
+ return "Dynamic"
+ case DiskTypeDifferencing:
+ return "Differencing"
+ }
+
+ return "UnknownDiskType"
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/factory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/factory.go
new file mode 100644
index 00000000000..b48377d245c
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/factory.go
@@ -0,0 +1,372 @@
+package footer
+
+import (
+ "fmt"
+ "time"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// Factory type is used to create Footer instance by reading vhd footer section.
+//
+type Factory struct {
+ vhdReader *reader.VhdReader
+ footerOffset int64
+}
+
+// NewFactory creates a new instance of Factory, which can be used to create a Footer
+// instance by reading the footer section using VhdReader.
+//
+func NewFactory(vhdReader *reader.VhdReader) *Factory {
+ return &Factory{vhdReader: vhdReader, footerOffset: vhdReader.Size - vhdcore.VhdFooterSize}
+}
+
+// Create creates a Footer instance by reading the footer section of the disk.
+// This function return error if any error occurs while reading or parsing the footer fields.
+//
+func (f *Factory) Create() (*Footer, error) {
+ footer := &Footer{}
+ var err error
+ errDone := func() (*Footer, error) {
+ return nil, err
+ }
+
+ footer.Cookie, err = f.readVhdCookie()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.Features, err = f.readFeatures()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.FileFormatVersion, err = f.readFileFormatVersion()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.HeaderOffset, err = f.readHeaderOffset()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.TimeStamp, err = f.readTimeStamp()
+ if err != nil {
+ return errDone()
+ }
+ footer.CreatorApplication, err = f.readCreatorApplication()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.CreatorVersion, err = f.readCreatorVersion()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.CreatorHostOsType, err = f.readCreatorHostOsType()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.PhysicalSize, err = f.readPhysicalSize()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.VirtualSize, err = f.readVirtualSize()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.DiskGeometry, err = f.readDiskGeometry()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.DiskType, err = f.readDiskType()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.CheckSum, err = f.readCheckSum()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.UniqueID, err = f.readUniqueID()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.SavedState, err = f.readSavedState()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.Reserved, err = f.readReserved()
+ if err != nil {
+ return errDone()
+ }
+
+ footer.RawData, err = f.readWholeFooter()
+ if err != nil {
+ return errDone()
+ }
+
+ return footer, nil
+}
+
+// readVhdCookie reads the vhd cookie string and returns it as an instance of VhdCookie.
+// This function returns error if the cookie is invalid, if no or fewer bytes could be
+// read. Cookie is stored as eight-character ASCII string starting at offset 0 relative
+// to the beginning of footer.
+//
+func (f *Factory) readVhdCookie() (*vhdcore.Cookie, error) {
+ cookieData := make([]byte, 8)
+ if _, err := f.vhdReader.ReadBytes(f.footerOffset+0, cookieData); err != nil {
+ return nil, NewParseError("Cookie", err)
+ }
+
+ cookie := vhdcore.CreateNewVhdCookie(false, cookieData)
+ if !cookie.IsValid() {
+ return nil, NewParseError("Cookie", fmt.Errorf("Invalid footer cookie data %v", cookieData))
+ }
+ return cookie, nil
+}
+
+// readFeatures reads and return the feature field. This function return error if no or
+// fewer bytes could be read.
+// Feature is stored as 4 bytes value starting at offset 8 relative to the beginning of
+// footer.
+//
+func (f *Factory) readFeatures() (VhdFeature, error) {
+ value, err := f.vhdReader.ReadUInt32(f.footerOffset + 8)
+ if err != nil {
+ return VhdFeatureNoFeaturesEnabled, NewParseError("Features", err)
+ }
+ return VhdFeature(value), nil
+}
+
+// readFileFormatVersion reads and return the VhdFileFormatVersion field from the footer.
+// This function is return error if no or fewer bytes could be read.
+// VhdFileFormatVersion is stored as 4 bytes value starting at offset 12 relative to the
+// beginning of footer.
+//
+func (f *Factory) readFileFormatVersion() (VhdFileFormatVersion, error) {
+ value, err := f.vhdReader.ReadUInt32(f.footerOffset + 12)
+ if err != nil {
+ return VhdFileFormatVersionNone, NewParseError("FileFormatVersion", err)
+ }
+ return VhdFileFormatVersion(value), nil
+}
+
+// readHeaderOffset reads and return the absolute offset to the header structure.
+// This function return error if no or fewer bytes could be read.
+// Header offset is stored as 8 bytes value starting at offset 16 relative to the beginning
+// of footer. This value is stored in big-endian format.
+//
+func (f *Factory) readHeaderOffset() (int64, error) {
+ value, err := f.vhdReader.ReadInt64(f.footerOffset + 16)
+ if err != nil {
+ return -1, NewParseError("HeaderOffset", err)
+ }
+ return value, nil
+}
+
+// readTimeStamp reads the creation time of the disk which is stored as the number of seconds
+// since January 1, 2000 12:00:00 AM in UTC/GMT and return it as instance of time.Time.
+// This function return error if no or fewer bytes could be read.
+// TimeStamp is stored as 4 bytes value starting at offset 24 relative to the beginning
+// of footer. This value is stored in big-endian format.
+//
+func (f *Factory) readTimeStamp() (*time.Time, error) {
+ value, err := f.vhdReader.ReadDateTime(f.footerOffset + 24)
+ if err != nil {
+ return nil, NewParseError("TimeStamp", err)
+ }
+ return value, nil
+}
+
+// readCreatorApplication reads the value of the field containing identity of the application
+// used to create the disk. The field is a left-justified text field. It uses a single-byte
+// character set. This function return error if no or fewer bytes could be read.
+// Identifier is stored as 4 bytes value starting at offset 28 relative to the beginning
+// of footer.
+//
+func (f *Factory) readCreatorApplication() (string, error) {
+ creatorApp := make([]byte, 4)
+ _, err := f.vhdReader.ReadBytes(f.footerOffset+28, creatorApp)
+ if err != nil {
+ return "", NewParseError("CreatorApplication", err)
+ }
+ return string(creatorApp), nil
+}
+
+// readCreatorVersion reads the value of the field the holds the major/minor version of the
+// application that created the hard disk image. This function return error if no or fewer
+// bytes could be read.
+// Version is stored as 4 bytes value starting at offset 32 relative to the beginning
+// of footer.
+//
+func (f *Factory) readCreatorVersion() (VhdCreatorVersion, error) {
+ value, err := f.vhdReader.ReadUInt32(f.footerOffset + 32)
+ if err != nil {
+ return VhdCreatorVersionNone, NewParseError("CreatorVersion", err)
+ }
+ return VhdCreatorVersion(value), nil
+}
+
+// readCreatorHostOsType reads the value of the field that stores the type of host operating
+// system this disk image is created on. Call to this function return error if no or fewer
+// bytes could be read.
+// Version is stored as 4 bytes value starting at offset 36 relative to the beginning
+// of footer.
+//
+func (f *Factory) readCreatorHostOsType() (HostOsType, error) {
+ value, err := f.vhdReader.ReadUInt32(f.footerOffset + 36)
+ if err != nil {
+ return HostOsTypeNone, NewParseError("CreatorHostOsType", err)
+ }
+ return HostOsType(value), nil
+}
+
+// readPhysicalSize reads the size of the hard disk in bytes, from the perspective of the
+// virtual machine, at creation time. This field is for informational purposes.
+// This function return error if no or fewer bytes could be read.
+// PhysicalSize is stored as 8 bytes value starting at offset 40 relative to the
+// beginning of footer. This size does not include the size consumed by vhd metadata such as
+// header, footer BAT, block's bitmap
+// This value is stored in big-endian format.
+//
+func (f *Factory) readPhysicalSize() (int64, error) {
+ value, err := f.vhdReader.ReadInt64(f.footerOffset + 40)
+ if err != nil {
+ return -1, NewParseError("PhysicalSize", err)
+ }
+ return value, nil
+}
+
+// readVirtualSize reads the size of the he current size of the hard disk, in bytes, from the
+// perspective of the virtual machine. This value is same as the PhysicalSize when the hard
+// disk is created. This value can change depending on whether the hard disk is expanded
+// This function return error if no or fewer bytes could be read.
+// VirtualSize is stored as 8 bytes value starting at offset 48 relative to the
+// beginning of footer. This size does not include the size consumed by vhd metadata such as
+// header, footer BAT, block's bitmap
+// This value is stored in big-endian format.
+//
+func (f *Factory) readVirtualSize() (int64, error) {
+ value, err := f.vhdReader.ReadInt64(f.footerOffset + 48)
+ if err != nil {
+ return -1, NewParseError("VirtualSize", err)
+ }
+ return value, nil
+}
+
+// readDiskGeometry reads the 4 byte value that stores the cylinder, heads, and sectors per
+// track value for the hard disk. This function return error if no or fewer bytes could
+// be read. The value is stored starting starting at offset 56 relative to the beginning of
+// footer. This value is stored in big-endian format.
+//
+func (f *Factory) readDiskGeometry() (*DiskGeometry, error) {
+ diskGeometry := &DiskGeometry{}
+ cylinder, err := f.vhdReader.ReadUInt16(f.footerOffset + 56 + 0)
+ if err != nil {
+ return nil, NewParseError("DiskGeometry::Cylinder", err)
+ }
+ diskGeometry.Cylinder = cylinder
+ heads, err := f.vhdReader.ReadByte(f.footerOffset + 56 + 2)
+ if err != nil {
+ return nil, NewParseError("DiskGeometry::Heads", err)
+ }
+ diskGeometry.Heads = heads
+ sectors, err := f.vhdReader.ReadByte(f.footerOffset + 56 + 3)
+ if err != nil {
+ return nil, NewParseError("DiskGeometry::Sectors", err)
+ }
+ diskGeometry.Sectors = sectors
+ return diskGeometry, nil
+}
+
+// readDiskType reads the field stores type of the disk (fixed, differencing, dynamic)
+// This function return error if no or fewer bytes could be read.
+// The value is stored as 4 byte value starting at offset 60 relative to the beginning
+// of footer. This value is stored in big-endian format.
+//
+func (f *Factory) readDiskType() (DiskType, error) {
+ value, err := f.vhdReader.ReadUInt32(f.footerOffset + 60)
+ if err != nil {
+ return DiskTypeNone, NewParseError("DiskType", err)
+ }
+ return DiskType(value), nil
+}
+
+// readCheckSum reads the field that stores basic checksum of the hard disk footer.
+// This function return error if no or fewer bytes could be read.
+// The value is stored as 4 byte value starting at offset 64 relative to the beginning
+// of footer. This value is stored in big-endian format.
+//
+func (f *Factory) readCheckSum() (uint32, error) {
+ value, err := f.vhdReader.ReadUInt32(f.footerOffset + 64)
+ if err != nil {
+ return 0, NewParseError("CheckSum", err)
+ }
+ return value, nil
+}
+
+// readUniqueId reads the field that stores unique ID used to identify the hard disk.
+// This is a 128-bit universally unique identifier (UUID)
+// This function return error if no or fewer bytes could be read.
+// The value is stored as 16 byte value starting at offset 68 relative to the beginning
+// of footer.
+//
+func (f *Factory) readUniqueID() (*common.UUID, error) {
+ value, err := f.vhdReader.ReadUUID(f.footerOffset + 68)
+ if err != nil {
+ return nil, NewParseError("UniqueId", err)
+ }
+ return value, nil
+}
+
+// readSavedState reads the flag indicating whether the system is in saved state.
+// This function return error if the byte could be read.
+// The value is stored as 1 byte value starting at offset 84 relative to the beginning
+// of footer.
+//
+func (f *Factory) readSavedState() (bool, error) {
+ value, err := f.vhdReader.ReadBoolean(f.footerOffset + 84)
+ if err != nil {
+ return false, NewParseError("SavedState", err)
+ }
+ return value, err
+}
+
+// readReserved reads the reserved field which currently contains zeroes.
+// This function return error if the byte could be read.
+// It is 427 bytes in size starting at offset 85 relative to the beginning
+// of footer.
+//
+func (f *Factory) readReserved() ([]byte, error) {
+ reserved := make([]byte, 427)
+ _, err := f.vhdReader.ReadBytes(f.footerOffset+85, reserved)
+ if err != nil {
+ return nil, NewParseError("Reserved", err)
+ }
+ return reserved, nil
+}
+
+// readWholeFooter reads the entire footer as a raw bytes. This function return
+// error if the byte could be read.
+//
+func (f *Factory) readWholeFooter() ([]byte, error) {
+ rawData := make([]byte, 512)
+ _, err := f.vhdReader.ReadBytes(f.footerOffset+0, rawData)
+ if err != nil {
+ return nil, err
+ }
+ return rawData, nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/footer.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/footer.go
new file mode 100644
index 00000000000..90515b5668c
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/footer.go
@@ -0,0 +1,108 @@
+package footer
+
+import (
+ "bytes"
+ "time"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+)
+
+// Footer represents the footer of the vhd, the size of the footer is 512 bytes.
+// The last 512 bytes of the disk is footer. In case of dynamic and differential
+// vhds, the footer is replicated at the beginning of the disk as well.
+//
+type Footer struct {
+ // Offset = 0, Size = 8
+ Cookie *vhdcore.Cookie
+ // Offset = 8, Size = 4
+ Features VhdFeature
+ // Offset = 12, Size = 4
+ FileFormatVersion VhdFileFormatVersion
+ // Offset = 16, Size = 8
+ // Absolute byte offset to the header structure, this is used for dynamic disks
+ // and differencing disks. Fixed disk does not have header this field is set to
+ // 0xFFFFFFFF for fixed disk.
+ HeaderOffset int64
+ // Offset = 24, Size = 4
+ TimeStamp *time.Time
+ // Offset = 28, Size = 4
+ CreatorApplication string
+ // Offset = 32, Size = 4
+ CreatorVersion VhdCreatorVersion
+ // Offset = 36, Size = 4
+ CreatorHostOsType HostOsType
+ // Offset = 40, Size = 8
+ PhysicalSize int64
+ // Offset = 48, Size = 8
+ VirtualSize int64
+ // Offset = 56, Size = 4
+ DiskGeometry *DiskGeometry
+ // Offset = 60, Size = 4
+ DiskType DiskType
+ // Offset = 64, Size = 4
+ CheckSum uint32
+ // Offset = 68, Size = 16
+ UniqueID *common.UUID
+ // Offset = 84, Size = 1
+ SavedState bool
+ // Offset = 85, Size = 427
+ Reserved []byte
+ // Offset = 0, Size = 512
+ RawData []byte
+}
+
+// CreateCopy creates and returns a deep copy of this instance.
+//
+func (v *Footer) CreateCopy() *Footer {
+ return &Footer{
+ Cookie: v.Cookie.CreateCopy(),
+ Features: v.Features,
+ FileFormatVersion: v.FileFormatVersion,
+ HeaderOffset: v.HeaderOffset,
+ TimeStamp: v.TimeStamp,
+ CreatorApplication: v.CreatorApplication,
+ CreatorVersion: v.CreatorVersion,
+ CreatorHostOsType: v.CreatorHostOsType,
+ PhysicalSize: v.PhysicalSize,
+ VirtualSize: v.VirtualSize,
+ DiskGeometry: v.DiskGeometry.CreateCopy(),
+ DiskType: v.DiskType,
+ CheckSum: v.CheckSum,
+ UniqueID: v.UniqueID,
+ SavedState: v.SavedState,
+ Reserved: common.CreateByteSliceCopy(v.Reserved),
+ RawData: common.CreateByteSliceCopy(v.RawData),
+ }
+}
+
+// Equal returns true if this and other points to the same instance or if contents
+// of the fields of these two instances are same.
+//
+func (v *Footer) Equal(other *Footer) bool {
+ if other == nil {
+ return false
+ }
+
+ if v == other {
+ return true
+ }
+
+ return v.Cookie.Equal(other.Cookie) &&
+ v.Features == other.Features &&
+ v.FileFormatVersion == other.FileFormatVersion &&
+ v.HeaderOffset == other.HeaderOffset &&
+ v.TimeStamp == other.TimeStamp &&
+ v.CreatorApplication == other.CreatorApplication &&
+ v.CreatorVersion == other.CreatorVersion &&
+ v.CreatorHostOsType == other.CreatorHostOsType &&
+ v.PhysicalSize == other.PhysicalSize &&
+ v.VirtualSize == other.VirtualSize &&
+ v.DiskGeometry.Equals(other.DiskGeometry) &&
+ v.DiskType == other.DiskType &&
+ v.CheckSum == other.CheckSum &&
+ v.UniqueID == other.UniqueID &&
+ v.SavedState == other.SavedState &&
+ bytes.Equal(v.Reserved, other.Reserved) &&
+ bytes.Equal(v.RawData, other.RawData)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/hostOsType.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/hostOsType.go
new file mode 100644
index 00000000000..8f3e81cb923
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/hostOsType.go
@@ -0,0 +1,32 @@
+package footer
+
+import "fmt"
+
+// HostOsType represents the host operating system a disk image is created on.
+// Value is stored in the footer in big-endian format.
+//
+type HostOsType uint32
+
+const (
+ // HostOsTypeNone represents a nil host OS type
+ HostOsTypeNone HostOsType = 0
+ // HostOsTypeWindows represents a Windows OS type
+ HostOsTypeWindows HostOsType = 0x5769326B
+ // HostOsTypeMacintosh represents a MAC OS type
+ HostOsTypeMacintosh HostOsType = 0x4D616320
+)
+
+// String returns the string representation of the HostOsType. If the int type
+// value does not match with the predefined OS types then this function convert
+// the int to string and return
+//
+func (h HostOsType) String() string {
+ switch h {
+ case HostOsTypeWindows:
+ return "Windows"
+ case HostOsTypeMacintosh:
+ return "Macintosh"
+ }
+
+ return fmt.Sprintf("%d", h)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/parseError.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/parseError.go
new file mode 100644
index 00000000000..37c91eb31a8
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/parseError.go
@@ -0,0 +1,31 @@
+package footer
+
+// ParseError is the error type representing disk footer parse error.
+//
+type ParseError struct {
+ FooterField string
+ err error
+}
+
+// Error returns the string representation of the ParseError instance.
+//
+func (e *ParseError) Error() string {
+ return "Parse footer field" + " '" + e.FooterField + "' failed: " + e.err.Error()
+}
+
+// GetInnerErr returns the inner error, this method satisfies InnerErr interface
+//
+func (e *ParseError) GetInnerErr() error {
+ return e.err
+}
+
+// NewParseError returns a new ParseError instance.
+// The parameter footerField represents the field in the footer that failed to parse
+// The parameter err is the underlying error for parse failure.
+//
+func NewParseError(footerField string, err error) error {
+ return &ParseError{
+ FooterField: footerField,
+ err: err,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdCreatorVersion.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdCreatorVersion.go
new file mode 100644
index 00000000000..c3baae3db66
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdCreatorVersion.go
@@ -0,0 +1,37 @@
+package footer
+
+import "fmt"
+
+// VhdCreatorVersion represents the major/minor version of the application that
+// created the hard disk image. The version is stored in the vhd footer in
+// big-endian format.
+//
+type VhdCreatorVersion uint32
+
+const (
+ // VhdCreatorVersionNone represents a nil host Creator version
+ VhdCreatorVersionNone VhdCreatorVersion = 0
+ // VhdCreatorVersionVS2004 represents the value set by Virtual Server 2004
+ VhdCreatorVersionVS2004 VhdCreatorVersion = 0x00010000
+ // VhdCreatorVersionVPC2004 represents the value set by Virtual PC 2004
+ VhdCreatorVersionVPC2004 VhdCreatorVersion = 0x00050000
+ // VhdCreatorVersionCSUP2011 represents a value set by CSUP 2011
+ VhdCreatorVersionCSUP2011 VhdCreatorVersion = 0x00070000
+)
+
+// String returns the string representation of the VhdCreatorVersion. If the int
+// VhdCreatorVersion value does not match with the predefined CreatorVersions then
+// this function convert the int to string and return.
+//
+func (v VhdCreatorVersion) String() string {
+ switch v {
+ case VhdCreatorVersionVS2004:
+ return "VS2004"
+ case VhdCreatorVersionVPC2004:
+ return "VPC2004"
+ case VhdCreatorVersionCSUP2011:
+ return "SUP2011"
+ }
+
+ return fmt.Sprintf("%d", v)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFeature.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFeature.go
new file mode 100644
index 00000000000..6f331f95666
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFeature.go
@@ -0,0 +1,39 @@
+package footer
+
+import "fmt"
+
+// VhdFeature represents a bit field used to indicate specific feature support.
+// Value is stored in the footer in big-endian format.
+//
+type VhdFeature uint32
+
+const (
+ // VhdFeatureNoFeaturesEnabled indicates that hard disk image has no special features enabled in it.
+ //
+ VhdFeatureNoFeaturesEnabled VhdFeature = 0x00000000
+ // VhdFeatureTemporary indicates that current disk is a temporary disk. A temporary disk designation
+ // indicates to an application that this disk is a candidate for deletion on shutdown.
+ //
+ VhdFeatureTemporary = 0x00000001
+ // VhdFeatureReserved represents a bit must always be set to 1. All other bits are also reserved
+ // and should be set to 0
+ //
+ VhdFeatureReserved = 0x00000002
+)
+
+// String returns the string representation of the VhdFeature. If the int VhdFeature
+// value does not match with the predefined VhdFeatures then this function convert
+// int to string and return
+//
+func (v VhdFeature) String() string {
+ switch v {
+ case VhdFeatureNoFeaturesEnabled:
+ return "NoFeaturesEnabled"
+ case VhdFeatureTemporary:
+ return "Temporary"
+ case VhdFeatureReserved:
+ return "Reserved"
+ }
+
+ return fmt.Sprintf("%d", v)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFileFormatVersion.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFileFormatVersion.go
new file mode 100644
index 00000000000..ca539f0d2c3
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFileFormatVersion.go
@@ -0,0 +1,23 @@
+package footer
+
+// VhdFileFormatVersion represents the version of the specification used in creating
+// the vhd. The version is stored in the vhd footer in big-endian format.
+// This is a 4 byte value - most-significant two bytes are for the major version.
+// The least-significant two bytes are the minor version
+//
+type VhdFileFormatVersion uint32
+
+// VhdFileFormatVersionDefault represents the currently supported vhd specification version.
+//
+const VhdFileFormatVersionDefault VhdFileFormatVersion = 0x00010000
+
+// VhdFileFormatVersionNone represents invalid version
+//
+const VhdFileFormatVersionNone VhdFileFormatVersion = 0
+
+// IsSupported returns true if this instance represents a supported vhd specification
+// version.
+//
+func (v VhdFileFormatVersion) IsSupported() bool {
+ return v == VhdFileFormatVersionDefault
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFooterSerializer.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFooterSerializer.go
new file mode 100644
index 00000000000..acf431464b7
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/footer/vhdFooterSerializer.go
@@ -0,0 +1,50 @@
+package footer
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/writer"
+)
+
+// SerializeFooter returns the given VhdFooter instance as byte slice of length 512 bytes.
+//
+func SerializeFooter(footer *Footer) []byte {
+ buffer := make([]byte, vhdcore.VhdFooterSize)
+ writer := writer.NewVhdWriterFromByteSlice(buffer)
+
+ writer.WriteBytes(0, footer.Cookie.Data)
+ writer.WriteUInt32(8, uint32(footer.Features))
+ writer.WriteUInt32(12, uint32(footer.FileFormatVersion))
+ writer.WriteInt64(16, footer.HeaderOffset)
+ writer.WriteTimeStamp(24, footer.TimeStamp)
+ creatorApp := make([]byte, 4)
+ copy(creatorApp, footer.CreatorApplication)
+ writer.WriteBytes(28, creatorApp)
+ writer.WriteUInt32(32, uint32(footer.CreatorVersion))
+ writer.WriteUInt32(36, uint32(footer.CreatorHostOsType))
+ writer.WriteInt64(40, footer.PhysicalSize)
+ writer.WriteInt64(48, footer.VirtualSize)
+ // + DiskGeometry
+ writer.WriteUInt16(56, footer.DiskGeometry.Cylinder)
+ writer.WriteByte(58, footer.DiskGeometry.Heads)
+ writer.WriteByte(59, footer.DiskGeometry.Sectors)
+ // - DiskGeometry
+ writer.WriteUInt32(60, uint32(footer.DiskType))
+ writer.WriteBytes(68, footer.UniqueID.ToByteSlice())
+ writer.WriteBoolean(84, footer.SavedState)
+ writer.WriteBytes(85, footer.Reserved)
+ // + Checksum
+ //
+ // Checksum is one’s complement of the sum of all the bytes in the footer without the
+ // checksum field.
+ checkSum := uint32(0)
+ for i := int(0); i < int(vhdcore.VhdFooterSize); i++ {
+ if i < vhdcore.VhdFooterChecksumOffset || i >= vhdcore.VhdFooterChecksumOffset+4 {
+ checkSum += uint32(buffer[i])
+ }
+ }
+
+ writer.WriteUInt32(64, ^checkSum)
+ // - Checksum
+
+ return buffer
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/factory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/factory.go
new file mode 100644
index 00000000000..1ca1d67975d
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/factory.go
@@ -0,0 +1,290 @@
+package header
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// Factory type is used to create VhdHeader instance by reading vhd header section.
+//
+type Factory struct {
+ vhdReader *reader.VhdReader
+ headerOffset int64
+}
+
+// NewFactory creates a new instance of Factory, which can be used to create
+// a VhdHeader instance by reading the header section using vhdReader.
+//
+func NewFactory(vhdReader *reader.VhdReader, headerOffset int64) *Factory {
+ return &Factory{vhdReader: vhdReader, headerOffset: headerOffset}
+}
+
+// Create creates a Header instance by reading the header section of a expandable disk.
+// This function return error if any error occurs while reading or parsing the header fields.
+//
+func (f *Factory) Create() (*Header, error) {
+ header := &Header{}
+ var err error
+ errDone := func() (*Header, error) {
+ return nil, err
+ }
+
+ header.Cookie, err = f.readHeaderCookie()
+ if err != nil {
+ return errDone()
+ }
+
+ header.DataOffset, err = f.readDataOffset()
+ if err != nil {
+ return errDone()
+ }
+
+ header.TableOffset, err = f.readBATOffset()
+ if err != nil {
+ return errDone()
+ }
+
+ header.HeaderVersion, err = f.readHeaderVersion()
+ if err != nil {
+ return errDone()
+ }
+
+ header.MaxTableEntries, err = f.readMaxBATEntries()
+ if err != nil {
+ return errDone()
+ }
+
+ header.BlockSize, err = f.readBlockSize()
+ if err != nil {
+ return errDone()
+ }
+
+ header.CheckSum, err = f.readCheckSum()
+ if err != nil {
+ return errDone()
+ }
+
+ header.ParentUniqueID, err = f.readParentUniqueID()
+ if err != nil {
+ return errDone()
+ }
+
+ header.ParentTimeStamp, err = f.readParentTimeStamp()
+ if err != nil {
+ return errDone()
+ }
+
+ header.Reserved, err = f.readReserved()
+ if err != nil {
+ return errDone()
+ }
+
+ header.ParentPath, err = f.readParentPath()
+ if err != nil {
+ return errDone()
+ }
+
+ header.ParentLocators, err = f.readParentLocators()
+ if err != nil {
+ return errDone()
+ }
+
+ header.RawData, err = f.readWholeHeader()
+ if err != nil {
+ return errDone()
+ }
+
+ return header, nil
+}
+
+// readHeaderCookie reads the vhd cookie string and returns it as an instance of VhdCookie.
+// This function return error if the cookie is invalid, if no or fewer bytes could be read.
+// Cookie is stored as eight-character ASCII string starting at offset 0 relative to the beginning
+// of header.
+//
+func (f *Factory) readHeaderCookie() (*vhdcore.Cookie, error) {
+ cookieData := make([]byte, 8)
+ if _, err := f.vhdReader.ReadBytes(f.headerOffset+0, cookieData); err != nil {
+ return nil, NewParseError("Cookie", err)
+ }
+
+ cookie := vhdcore.CreateNewVhdCookie(true, cookieData)
+ if !cookie.IsValid() {
+ return nil, NewParseError("Cookie", fmt.Errorf("Invalid header cookie data %v", cookieData))
+ }
+ return cookie, nil
+}
+
+// readDataOffset reads and return the absolute offset to the next structure in the disk. This field
+// is currently unused and holds the value 0xFFFFFFFF. This function return error if no or fewer
+// bytes could be read.
+// This value is stored as 8 bytes value starting at offset 8 relative to the beginning of header.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readDataOffset() (int64, error) {
+ value, err := f.vhdReader.ReadInt64(f.headerOffset + 8)
+ if err != nil {
+ return -1, NewParseError("DataOffset", err)
+ }
+ return value, nil
+}
+
+// readBATOffset reads and return the absolute offset to the the Block Allocation Table (BAT) in the
+// disk. This function return error if no or fewer bytes could be read.
+// BATOffset is stored as 8 bytes value starting at offset 16 relative to the beginning of header.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readBATOffset() (int64, error) {
+ value, err := f.vhdReader.ReadInt64(f.headerOffset + 16)
+ if err != nil {
+ return -1, NewParseError("BATOffset", err)
+ }
+ return value, nil
+}
+
+// readHeaderVersion reads the value of the field the holds the major/minor version of the disk header.
+// This function return error if no or fewer bytes could be read. HeaderVersion is stored as 4 bytes
+// value starting at offset 24 relative to the beginning of header.
+//
+func (f *Factory) readHeaderVersion() (VhdHeaderVersion, error) {
+ value, err := f.vhdReader.ReadUInt32(f.headerOffset + 24)
+ if err != nil {
+ return VhdHeaderVersionNone, NewParseError("HeaderVersion", err)
+ }
+ v := VhdHeaderVersion(value)
+ if !v.IsSupported() {
+ return VhdHeaderVersionNone,
+ NewParseError("HeaderVersion", fmt.Errorf("Invalid header version %v, unsupported format", v))
+ }
+ return v, nil
+}
+
+// readMaxTableEntries reads and return maximum entries present in the BAT. This function return
+// error if no or fewer bytes could be read.
+// MaxTableEntries is stored as 4 bytes value starting at offset 28 relative to the beginning of
+// header. This value is stored in big-endian format.
+//
+func (f *Factory) readMaxBATEntries() (uint32, error) {
+ value, err := f.vhdReader.ReadUInt32(f.headerOffset + 28)
+ if err != nil {
+ return 0, NewParseError("MaxBATEntries", err)
+ }
+ return value, nil
+}
+
+// readBlockSize reads size of the 'data section' of a block, this does not include size of 'block
+// bitmap section'. This function return error if no or fewer bytes could be read.
+// BlockSize is stored as 4 bytes value starting at offset 32 relative to the beginning of header.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readBlockSize() (uint32, error) {
+ value, err := f.vhdReader.ReadUInt32(f.headerOffset + 32)
+ if err != nil {
+ return 0, NewParseError("BlockSize", err)
+ }
+ return value, nil
+}
+
+// readCheckSum reads the field that stores basic checksum of the hard disk header.
+// This function return error if no or fewer bytes could be read.
+// The value is stored as 4 byte value starting at offset 36 relative to the beginning of header.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readCheckSum() (uint32, error) {
+ value, err := f.vhdReader.ReadUInt32(f.headerOffset + 36)
+ if err != nil {
+ return 0, NewParseError("CheckSum", err)
+ }
+ return value, nil
+}
+
+// readParentUniqueId reads the field that stores unique ID used to identify the parent disk. This
+// field is used only for differencing disk. This is a 128-bit universally unique identifier (UUID).
+// This function return error if no or fewer bytes could be read.
+// The value is stored as 16 byte value starting at offset 40 relative to the beginning of header.
+//
+func (f *Factory) readParentUniqueID() (*common.UUID, error) {
+ value, err := f.vhdReader.ReadUUID(f.headerOffset + 40)
+ if err != nil {
+ return nil, NewParseError("ParentUniqueId", err)
+ }
+ return value, nil
+}
+
+// readTimeStamp reads the field storing modification time stamp of the parent hard disk which is
+// stored as the number of seconds since January 1, 2000 12:00:00 AM in UTC/GMT and return it as
+// instance of time.Time. This function return error if no or fewer bytes could be read.
+// TimeStamp is stored as 4 bytes value starting at offset 56 relative to the beginning of header.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readParentTimeStamp() (*time.Time, error) {
+ value, err := f.vhdReader.ReadDateTime(f.headerOffset + 56)
+ if err != nil {
+ return nil, NewParseError("ParentTimeStamp", err)
+ }
+ return value, nil
+}
+
+// readReserved reads the reserved field which is not used and all set to zero. This function return
+// error if no or fewer bytes could be read. Reserved is stored as 4 bytes value starting at offset
+// 60 relative to the beginning of header. This value is stored in big-endian format.
+//
+func (f *Factory) readReserved() (uint32, error) {
+ value, err := f.vhdReader.ReadUInt32(f.headerOffset + 60)
+ if err != nil {
+ return 0, NewParseError("Reserved", err)
+ }
+ return value, nil
+}
+
+// readParentPath reads the field storing parent hard disk file name. This function return error if
+// no or fewer bytes could be read. ParentPath is stored in UTF-16 as big-endian format, its length is
+// 512 bytes, starting at offset 64 relative to the beginning of header.
+//
+func (f *Factory) readParentPath() (string, error) {
+ parentPath := make([]byte, 512)
+ _, err := f.vhdReader.ReadBytes(f.headerOffset+64, parentPath)
+ if err != nil {
+ return "", NewParseError("ParentPath", err)
+ }
+ return strings.TrimSuffix(common.Utf16BytesToStringBE(parentPath), "\x00"), nil
+}
+
+// readParentLocators reads the collection of parent locator entries. This function return error if
+// no or fewer bytes could be read. There are 8 entries, each 24 bytes, starting at offset 576 relative
+// to the beginning of header.
+//
+func (f *Factory) readParentLocators() (parentlocator.ParentLocators, error) {
+ var err error
+ count := 8
+ parentLocators := make(parentlocator.ParentLocators, count)
+ offset := f.headerOffset + 576
+ for i := 0; i < count; i++ {
+ parentLocFac := parentlocator.NewFactory(f.vhdReader, offset)
+ parentLocators[i], err = parentLocFac.Create()
+ if err != nil {
+ return nil, NewParseError("ParentLocator", err)
+ }
+ offset += 24
+ }
+
+ return parentLocators, nil
+}
+
+// readWholeHeader reads the entire header as a raw bytes. This function return error if the byte
+// could be read.
+//
+func (f *Factory) readWholeHeader() ([]byte, error) {
+ rawData := make([]byte, 1024)
+ _, err := f.vhdReader.ReadBytes(f.headerOffset+0, rawData)
+ if err != nil {
+ return nil, err
+ }
+ return rawData, nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/header.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/header.go
new file mode 100644
index 00000000000..12535fb9237
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/header.go
@@ -0,0 +1,54 @@
+package header
+
+import (
+ "time"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator"
+)
+
+// Header represents the header of the vhd, size of the header is 1024 bytes.
+// The header structure is present only for expanding disks (i.e. dynamic and
+// differencing disks.) In case of dynamic and differential vhds the footer is
+// replicated at the beginning of the disk as well, the header structure follows
+// this replicated footer, the field 'HeaderOffset' in the footer contains absolute
+// offset to the header structure.
+//
+type Header struct {
+ // Offset = 0, Size = 8
+ Cookie *vhdcore.Cookie
+ // Offset = 8, Size = 8
+ DataOffset int64
+ // Offset = 16, Size = 8
+ TableOffset int64
+ // Offset = 24, Size = 4
+ HeaderVersion VhdHeaderVersion
+ // Offset = 28, Size = 4
+ MaxTableEntries uint32
+ // Offset = 32, Size = 4
+ BlockSize uint32
+ // Offset = 36, Size = 4
+ CheckSum uint32
+ // Offset = 40, Size = 16
+ ParentUniqueID *common.UUID
+ // Offset = 56, Size = 4
+ ParentTimeStamp *time.Time
+ // Offset = 60, Size = 4
+ Reserved uint32
+ // Offset = 64, Size = 512
+ // This field contains a Unicode string (UTF-16) of the parent hard disk filename.
+ // This will be absolute path to the parent disk of differencing disk.
+ // If this field is set, then the ParentLocators collection will also contain
+ // an entry with the same path, the PlatformCode of that field will be PlatformCodeW2Ku.
+ ParentPath string
+ // Offset = 576, Count = 8
+ // Collection of entries store an absolute byte offset in the file where the
+ // parent locator for a differencing hard disk is stored.
+ // This field is used only for differencing disks and will be set to zero for
+ // dynamic disks.
+ ParentLocators parentlocator.ParentLocators
+ // Offset = 0, Size = 1024
+ // The entire header as raw bytes
+ RawData []byte
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/factory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/factory.go
new file mode 100644
index 00000000000..654c0af476e
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/factory.go
@@ -0,0 +1,135 @@
+package parentlocator
+
+import (
+ "fmt"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// Factory type is used to create ParentLocator instance by reading one entry
+// in vhd header's parent-hard-disk-locator-info collection section.
+//
+type Factory struct {
+ vhdReader *reader.VhdReader
+ locatorOffset int64
+}
+
+// NewFactory creates a new instance of Factory, which can be used to create ParentLocator instance
+// by reading one entry from the vhd header's parent-hard-disk-locator-info collection,
+// locatorOffset is the offset of the entry to read, vhdReader is the reader to be used to read the entry.
+//
+func NewFactory(vhdReader *reader.VhdReader, locatorOffset int64) *Factory {
+ return &Factory{vhdReader: vhdReader, locatorOffset: locatorOffset}
+}
+
+// Create creates a ParentLocator instance by reading one entry in vhd header's parent-hard-disk-locator-info
+// collection section of the disk. This function return error if any error occurs while reading or parsing
+// the parent locators table fields.
+//
+func (f *Factory) Create() (*ParentLocator, error) {
+ locator := &ParentLocator{}
+ var err error
+ errDone := func() (*ParentLocator, error) {
+ return nil, err
+ }
+
+ locator.PlatformCode, err = f.readPlatformCode()
+ if err != nil {
+ return errDone()
+ }
+
+ locator.PlatformDataSpace, err = f.readPlatformDataSpace()
+ if err != nil {
+ return errDone()
+ }
+
+ locator.PlatformDataLength, err = f.readPlatformDataLength()
+ if err != nil {
+ return errDone()
+ }
+
+ locator.Reserved, err = f.readReserved()
+ if err != nil {
+ return errDone()
+ }
+
+ locator.PlatformDataOffset, err = f.readPlatformDataOffset()
+ if err != nil {
+ return errDone()
+ }
+
+ fileLocator := make([]byte, locator.PlatformDataLength)
+ _, err = f.vhdReader.ReadBytes(locator.PlatformDataOffset, fileLocator)
+ if err != nil {
+ err = NewParseError("ParentLocator", fmt.Errorf("Unable to resolve file locator: %v", err))
+ return errDone()
+ }
+
+ locator.SetPlatformSpecificFileLocator(fileLocator)
+ return locator, nil
+}
+
+// readPlatformCode reads the field that stores the platform-specific format used to encode the
+// file locator in parent-hard-disk-locator-info
+// This function return error if no or fewer bytes could be read. The value is stored as 4 byte
+// value starting at offset 0 relative to the beginning of this parent-hard-disk-locator. This value
+// is stored in big-endian format.
+//
+func (f *Factory) readPlatformCode() (PlatformCode, error) {
+ value, err := f.vhdReader.ReadInt32(f.locatorOffset + 0)
+ if err != nil {
+ return PlatformCodeNone, NewParseError("PlatformCode", err)
+ }
+ return PlatformCode(value), nil
+}
+
+// readPlatformDataSpace reads the field that stores the number of 512-byte sectors needed to store
+// the parent hard disk file locator. This function return error if no or fewer bytes could be read.
+// The value is stored as 4 byte value starting at offset 4 relative to the beginning parent-hard-disk-locator-info.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readPlatformDataSpace() (int32, error) {
+ value, err := f.vhdReader.ReadInt32(f.locatorOffset + 4)
+ if err != nil {
+ return -1, NewParseError("PlatformDataSpace", err)
+ }
+ return value, nil
+}
+
+// readPlatformDataLength reads the field that stores the actual length of the parent hard disk
+// locator in bytes. This function return error if no or fewer bytes could be read. The value is stored
+// as 4 byte value starting at offset 8 relative to the beginning parent-hard-disk-locator-info. This value
+// is stored in big-endian format.
+//
+func (f *Factory) readPlatformDataLength() (int32, error) {
+ value, err := f.vhdReader.ReadInt32(f.locatorOffset + 8)
+ if err != nil {
+ return -1, NewParseError("PlatformDataLength", err)
+ }
+ return value, nil
+}
+
+// readReserved reads the reserved field value which is currently set to 0.
+// This function return error if no or fewer bytes could be read. The value is stored as 4 byte
+// value starting at offset 12 relative to the beginning parent-hard-disk-locator-info.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readReserved() (int32, error) {
+ value, err := f.vhdReader.ReadInt32(f.locatorOffset + 12)
+ if err != nil {
+ return -1, NewParseError("Reserved", err)
+ }
+ return value, nil
+}
+
+// readPlatformDataOffset reads the field that stores the absolute file offset in bytes where the platform
+// specific file locator data is stored. Call to this function is panic if no or fewer bytes could be read.
+// The value is stored as 4 byte value starting at offset 16 relative to the beginning parent-hard-disk-locator-info.
+// This value is stored in big-endian format.
+//
+func (f *Factory) readPlatformDataOffset() (int64, error) {
+ value, err := f.vhdReader.ReadInt64(f.locatorOffset + 16)
+ if err != nil {
+ return -1, NewParseError("PlatformDataOffset", err)
+ }
+ return value, nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parentLocator.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parentLocator.go
new file mode 100644
index 00000000000..4358a95c4ce
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parentLocator.go
@@ -0,0 +1,75 @@
+package parentlocator
+
+import (
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "log"
+ "strings"
+)
+
+// ParentLocator represents an entry in Parent locator table. Each entry represents
+// details (parent-hard-disk-locator-info) of file locator which is used to locate
+// the parent disk file of differencing hard disk.
+//
+type ParentLocator struct {
+ // Offset = 0, Size = 4
+ // This field stores the code representing the platform-specific format used for
+ // the file locator. Stored in big-endian format.
+ PlatformCode PlatformCode
+
+ // Offset = 4, Size = 4
+ // This field stores the number of 512-byte sectors needed to store the parent
+ // hard disk locator. Stored in big-endian format.
+ PlatformDataSpace int32
+
+ // Offset = 8, Size = 4
+ // This field stores the actual length of the parent hard disk locator in bytes.
+ // Stored in big-endian format.
+ PlatformDataLength int32
+
+ // Offset = 12, Size = 4
+ // This field must be set to zero.
+ // Stored in big-endian format.
+ Reserved int32
+
+ // Offset = 16, Size = 8
+ // This field stores the absolute file offset in bytes where the platform specific
+ // file locator data is stored. Stored in big-endian format.
+ PlatformDataOffset int64
+
+ // This is not a field that get stored or retrieved from disk's ParentLocator entry.
+ // We use this field to store the resolved file locator path.
+ PlatformSpecificFileLocator string
+}
+
+// SetPlatformSpecificFileLocator retrieves the file locator value and store that in the property
+// PlatformSpecificFileLocator
+//
+func (l *ParentLocator) SetPlatformSpecificFileLocator(fileLocator []byte) {
+ // 1. For the platform codes - W2Ru and W2Ku, fileLocator contents is UTF-16 encoded.
+ // 2. For the platform code - MacX, fileLocator contents is UTF-8 encoded.
+ // 3. For unknown platform code fileLocator contents is treated as UTF-16 encoded.
+ //
+ // For 1 the byte order is little-endian
+ // For 3 the byte order is big-endian
+
+ if l.PlatformCode == PlatformCodeWi2R || l.PlatformCode == PlatformCodeWi2K {
+ log.Panicf("Deprecated PlatformCode: %d", l.PlatformCode)
+ }
+
+ if l.PlatformCode == PlatformCodeMac {
+ log.Panicf("Handling Mac OS alias stored as a blob is not implemented, PlatformCode: %d", l.PlatformCode)
+ }
+
+ if l.PlatformCode == PlatformCodeNone {
+ l.PlatformSpecificFileLocator = ""
+ } else if l.PlatformCode == PlatformCodeW2Ru {
+ //TODO: Add differencing disks path name, this is relative path
+ l.PlatformSpecificFileLocator = common.Utf16BytesToStringLE(fileLocator)
+ } else if l.PlatformCode == PlatformCodeW2Ku {
+ l.PlatformSpecificFileLocator = common.Utf16BytesToStringLE(fileLocator)
+ } else if l.PlatformCode == PlatformCodeMacX {
+ l.PlatformSpecificFileLocator = string(fileLocator)
+ } else {
+ l.PlatformSpecificFileLocator = strings.TrimSuffix(common.Utf16BytesToStringBE(fileLocator), "\x00")
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parentLocators.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parentLocators.go
new file mode 100644
index 00000000000..ebec05d41df
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parentLocators.go
@@ -0,0 +1,33 @@
+package parentlocator
+
+// ParentLocators type represents the parent locator collection (parent-hard-disk-locator-info
+// collection). The collection entries store an absolute byte offset in the file where the parent
+// locator for a differencing hard disk is stored. This field is used only for differencing disks
+// and should be set to zero for dynamic disks.
+//
+type ParentLocators []*ParentLocator
+
+// GetAbsoluteParentPath returns the absolute path to the parent differencing hard disk
+//
+func (p ParentLocators) GetAbsoluteParentPath() string {
+ return p.getParentPath(PlatformCodeW2Ku)
+}
+
+// GetRelativeParentPath returns the relative path to the parent differencing hard disk
+//
+func (p ParentLocators) GetRelativeParentPath() string {
+ return p.getParentPath(PlatformCodeW2Ru)
+}
+
+// getParentPath returns path to the parent differencing hard disk corresponding to the
+// given platform code
+//
+func (p ParentLocators) getParentPath(code PlatformCode) string {
+ for _, l := range p {
+ if l.PlatformCode == code {
+ return l.PlatformSpecificFileLocator
+ }
+ }
+
+ return ""
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parseError.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parseError.go
new file mode 100644
index 00000000000..4d871687697
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/parseError.go
@@ -0,0 +1,31 @@
+package parentlocator
+
+// ParseError is the error type representing disk header parent locator parse error.
+//
+type ParseError struct {
+ LocatorField string
+ err error
+}
+
+// Error returns the string representation of the ParseError instance.
+//
+func (e *ParseError) Error() string {
+ return "Parse parent locator field" + " '" + e.LocatorField + "' failed: " + e.err.Error()
+}
+
+// GetInnerErr returns the inner error, this method satisfies InnerErr interface
+//
+func (e *ParseError) GetInnerErr() error {
+ return e.err
+}
+
+// NewParseError returns a new ParseError instance.
+// The parameter headerField represents the field in the header parent locator that failed to parse
+// The parameter err is the underlying error for parse failure.
+//
+func NewParseError(locatorField string, err error) error {
+ return &ParseError{
+ LocatorField: locatorField,
+ err: err,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/platformCode.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/platformCode.go
new file mode 100644
index 00000000000..217d0d12bd9
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator/platformCode.go
@@ -0,0 +1,59 @@
+package parentlocator
+
+import "fmt"
+
+// The PlatformCode describes which platform-specific format is used for the file locator
+// This is the type of PlatformCode field in ParentLocator type.
+//
+type PlatformCode int32
+
+const (
+ // PlatformCodeNone indicates a nil value for platform code.
+ //
+ PlatformCodeNone PlatformCode = 0x0
+ // PlatformCodeWi2R [deprecated]
+ //
+ PlatformCodeWi2R = 0x57693272
+ // PlatformCodeWi2K [deprecated]
+ //
+ PlatformCodeWi2K = 0x5769326B
+ // PlatformCodeW2Ru indicate that the file locator is stored in unicode (UTF-16) format on Windows
+ // relative to the differencing disk pathname.
+ //
+ PlatformCodeW2Ru = 0x57327275
+ // PlatformCodeW2Ku indicate that the file locator is stored in unicode (UTF-16) format as absolute
+ // pathname on Windows.
+ //
+ PlatformCodeW2Ku = 0x57326B75
+ // PlatformCodeMac indicates that file locator is a Mac OS alias stored as a blob.
+ //
+ PlatformCodeMac = 0x4D616320
+ // PlatformCodeMacX indicates that file locator is a file URL with UTF-8 encoding conforming to RFC 2396.
+ //
+ PlatformCodeMacX = 0x4D616358
+)
+
+// String returns the string representation of the PlatformCode. If the int platform code
+// value does not match with the predefined PlatformCodes then this function convert the
+// int to string and return
+//
+func (p PlatformCode) String() string {
+ switch p {
+ case PlatformCodeNone:
+ return "None"
+ case PlatformCodeWi2R:
+ return "Wi2R [deprecated]"
+ case PlatformCodeWi2K:
+ return "Wi2K [deprecated]"
+ case PlatformCodeW2Ru:
+ return "W2Ru"
+ case PlatformCodeW2Ku:
+ return "W2Ku"
+ case PlatformCodeMac:
+ return "Mac"
+ case PlatformCodeMacX:
+ return "MacX"
+ }
+
+ return fmt.Sprintf("%d", p)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parseError.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parseError.go
new file mode 100644
index 00000000000..c8a33b34dcc
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/parseError.go
@@ -0,0 +1,31 @@
+package header
+
+// ParseError is the error type representing disk header parse error.
+//
+type ParseError struct {
+ HeaderField string
+ err error
+}
+
+// Error returns the string representation of the ParseError instance.
+//
+func (e *ParseError) Error() string {
+ return "Parse header field" + " '" + e.HeaderField + "' failed: " + e.err.Error()
+}
+
+// GetInnerErr returns the inner error, this method satisfies InnerErr interface
+//
+func (e *ParseError) GetInnerErr() error {
+ return e.err
+}
+
+// NewParseError returns a new ParseError instance.
+// The parameter headerField represents the field in the header that failed to parse
+// The parameter err is the underlying error for parse failure.
+//
+func NewParseError(headerField string, err error) error {
+ return &ParseError{
+ HeaderField: headerField,
+ err: err,
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/vhdHeaderVersion.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/vhdHeaderVersion.go
new file mode 100644
index 00000000000..13c598e5494
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/header/vhdHeaderVersion.go
@@ -0,0 +1,22 @@
+package header
+
+// VhdHeaderVersion represents the major/minor version of the specification
+// used in creating the vhd. The version is stored in the vhd header in
+// big-endian format.
+//
+type VhdHeaderVersion uint32
+
+// VhdHeaderSupportedVersion indicates the current VHD specification version
+//
+const VhdHeaderSupportedVersion VhdHeaderVersion = 0x00010000
+
+// VhdHeaderVersionNone indicates an invalid VHD specification version
+//
+const VhdHeaderVersionNone = 0
+
+// IsSupported returns true if this instance represents a supported VHD specification
+// version.
+//
+func (v VhdHeaderVersion) IsSupported() bool {
+ return v == VhdHeaderSupportedVersion
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/reader/binaryReader.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/reader/binaryReader.go
new file mode 100644
index 00000000000..59f1174cb79
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/reader/binaryReader.go
@@ -0,0 +1,156 @@
+package reader
+
+import (
+ "encoding/binary"
+ "fmt"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/common"
+ "io"
+)
+
+// bufferSizeInBytes is the size of the buffer used by BinaryReader
+//
+const bufferSizeInBytes = 16
+
+// ReadAtReader interface that composes io.ReaderAt and io.Reader interfaces.
+//
+type ReadAtReader interface {
+ io.ReaderAt
+ io.Reader
+}
+
+// BinaryReader is the reader which can be used to read values of primitive types from a reader
+// The reader supports reading data stored both in little-endian or big-endian format.
+//
+type BinaryReader struct {
+ buffer []byte
+ order binary.ByteOrder
+ from ReadAtReader
+ Size int64
+}
+
+// NewBinaryReader creates a new instance of BinaryReader, from is the underlying data source
+// to read from, order is the byte order used to encode the data in the source, size is the
+// length of the data source in bytes.
+//
+func NewBinaryReader(from ReadAtReader, order binary.ByteOrder, size int64) *BinaryReader {
+ return &BinaryReader{
+ buffer: make([]byte, bufferSizeInBytes),
+ order: order,
+ from: from,
+ Size: size,
+ }
+}
+
+// ReadBytes reads exactly len(buf) bytes from r into buf. It returns the number of bytes
+// copied and an error if fewer bytes were read. The error is EOF only if no bytes were
+// read. If an EOF happens after reading some but not all the bytes, ReadBytes returns
+// ErrUnexpectedEOF. On return, n == len(buf) if and only if err == nil.
+//
+func (b *BinaryReader) ReadBytes(offset int64, buf []byte) (int, error) {
+ return b.from.ReadAt(buf, offset)
+}
+
+// ReadByte reads a byte from underlying source starting at byte offset off and returns it.
+//
+func (b *BinaryReader) ReadByte(offset int64) (byte, error) {
+ if _, err := b.readToBuffer(1, offset); err != nil {
+ return 0, err
+ }
+
+ return b.buffer[0], nil
+}
+
+// ReadBoolean reads a byte from underlying source starting at byte offset off and
+// returns it as a bool.
+//
+func (b *BinaryReader) ReadBoolean(offset int64) (bool, error) {
+ if _, err := b.readToBuffer(1, offset); err != nil {
+ return false, err
+ }
+ return b.buffer[0] != 0, nil
+}
+
+// ReadUInt16 reads an encoded unsigned 2 byte integer from underlying source starting
+// at byte offset off and return it as a uint16.
+//
+func (b *BinaryReader) ReadUInt16(offset int64) (uint16, error) {
+ if _, err := b.readToBuffer(2, offset); err != nil {
+ return 0, err
+ }
+ return b.order.Uint16(b.buffer), nil
+}
+
+// ReadInt16 reads an encoded signed 2 byte integer from underlying source starting
+// at byte offset off returns it as a int16.
+//
+func (b *BinaryReader) ReadInt16(off int64) (int16, error) {
+ if _, err := b.readToBuffer(2, off); err != nil {
+ return 0, err
+ }
+ return int16(b.order.Uint16(b.buffer)), nil
+}
+
+// ReadUInt32 reads an encoded unsigned 4 byte integer from underlying source starting
+// at byte offset off returns it as a uint32.
+//
+func (b *BinaryReader) ReadUInt32(off int64) (uint32, error) {
+ if _, err := b.readToBuffer(4, off); err != nil {
+ return 0, err
+ }
+ return b.order.Uint32(b.buffer), nil
+}
+
+// ReadInt32 reads an encoded signed 4 byte integer from underlying source starting
+// at byte offset off and returns it as a int32.
+//
+func (b *BinaryReader) ReadInt32(off int64) (int32, error) {
+ if _, err := b.readToBuffer(4, off); err != nil {
+ return 0, err
+ }
+ return int32(b.order.Uint32(b.buffer)), nil
+}
+
+// ReadUInt64 reads an encoded unsigned 8 byte integer from underlying source starting
+// at byte offset off and returns it as a uint64.
+//
+func (b *BinaryReader) ReadUInt64(off int64) (uint64, error) {
+ if _, err := b.readToBuffer(8, off); err != nil {
+ return 0, err
+ }
+ return b.order.Uint64(b.buffer), nil
+}
+
+// ReadInt64 reads an encoded signed 4 byte integer from underlying source starting
+// at byte offset off and and returns it as a int64.
+//
+func (b *BinaryReader) ReadInt64(off int64) (int64, error) {
+ if _, err := b.readToBuffer(8, off); err != nil {
+ return 0, err
+ }
+ return int64(b.order.Uint64(b.buffer)), nil
+}
+
+// ReadUUID reads 16 byte character sequence from underlying source starting
+// at byte offset off and returns it as a UUID.
+//
+func (b *BinaryReader) ReadUUID(off int64) (*common.UUID, error) {
+ if _, err := b.readToBuffer(16, off); err != nil {
+ return nil, err
+ }
+
+ return common.NewUUID(b.buffer)
+}
+
+// readToBuffer reads numBytes bytes from the source starting at byte offset off.
+// This function uses ReadAt to read the bytes. It returns the number of bytes read
+// and the error, if any.
+// ReadAt always returns a non-nil error when n < len(numBytes). At end of file, that
+// error is io.EOF.
+//
+func (b *BinaryReader) readToBuffer(numBytes int, off int64) (int, error) {
+ if numBytes > bufferSizeInBytes {
+ return 0, fmt.Errorf("Expected (0-%d) however found: %d", bufferSizeInBytes, numBytes)
+ }
+
+ return b.from.ReadAt(b.buffer[:numBytes], off)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/reader/vhdReader.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/reader/vhdReader.go
new file mode 100644
index 00000000000..d9ec5774f71
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/reader/vhdReader.go
@@ -0,0 +1,61 @@
+package reader
+
+import (
+ "bytes"
+ "encoding/binary"
+ "time"
+ "unsafe"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+)
+
+// VhdReader is the reader used by various components responsible for reading different
+// segments of VHD such as header, footer, BAT, block, bitmap and sector.
+//
+type VhdReader struct {
+ *BinaryReader
+}
+
+// NewVhdReader creates new instance of the VhdReader, that reads from the underlying
+// source, size is the size of the source in bytes.
+//
+func NewVhdReader(source ReadAtReader, size int64) *VhdReader {
+ var order binary.ByteOrder
+ if isLittleEndian() {
+ order = binary.BigEndian
+ } else {
+ order = binary.LittleEndian
+ }
+ return &VhdReader{NewBinaryReader(source, order, size)}
+}
+
+// NewVhdReaderFromByteSlice creates a new instance of VhdReader, that uses the given
+// byte slice as the underlying source to read from.
+//
+func NewVhdReaderFromByteSlice(b []byte) *VhdReader {
+ source := bytes.NewReader(b)
+ return NewVhdReader(source, int64(len(b)))
+}
+
+// ReadDateTime reads an encoded vhd timestamp from underlying source starting at byte
+// offset off and return it as a time.Time.
+//
+func (r *VhdReader) ReadDateTime(off int64) (*time.Time, error) {
+ d, err := r.ReadUInt32(off)
+ if err != nil {
+ return nil, err
+ }
+ vhdDateTime := vhdcore.NewVhdTimeStampFromSeconds(d).ToDateTime()
+ return &vhdDateTime, nil
+}
+
+// isLittleEndian returns true if the host machine is little endian, false for
+// big endian
+//
+func isLittleEndian() bool {
+ var i int32 = 0x01020304
+ u := unsafe.Pointer(&i)
+ pb := (*byte)(u)
+ b := *pb
+ return (b == 0x04)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/validator/validator.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/validator/validator.go
new file mode 100644
index 00000000000..218a76e386b
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/validator/validator.go
@@ -0,0 +1,34 @@
+package validator
+
+import (
+ "fmt"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile"
+)
+
+// oneTB is one TeraByte
+//
+const oneTB int64 = 1024 * 1024 * 1024 * 1024
+
+// ValidateVhd returns error if the vhdPath refer to invalid vhd.
+//
+func ValidateVhd(vhdPath string) error {
+ vFactory := &vhdfile.FileFactory{}
+ _, err := vFactory.Create(vhdPath)
+ if err != nil {
+ return fmt.Errorf("%s is not a valid VHD: %v", vhdPath, err)
+ }
+ return nil
+}
+
+// ValidateVhdSize returns error if size of the vhd referenced by vhdPath is more than
+// the maximum allowed size (1TB)
+//
+func ValidateVhdSize(vhdPath string) error {
+ stream, _ := diskstream.CreateNewDiskStream(vhdPath)
+ if stream.GetSize() > oneTB {
+ return fmt.Errorf("VHD size is too large ('%d'), maximum allowed size is '%d'", stream.GetSize(), oneTB)
+ }
+ return nil
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdCookie.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdCookie.go
new file mode 100644
index 00000000000..570ba1efcab
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdCookie.go
@@ -0,0 +1,82 @@
+package vhdcore
+
+import "bytes"
+
+// VhdFooterCookie is the cookie value stored in VHD footer
+// Microsoft uses the “conectix” string to identify a hard disk image created by
+// Microsoft Virtual Server, Virtual PC, and predecessor products. The cookie is
+// stored as an eight-character ASCII string with the “c” in the first byte,
+// the “o” in the second byte, and so on.
+//
+const VhdFooterCookie = "conectix"
+
+// VhdHeaderCookie is the header cookie which is always cxsparse
+//
+const VhdHeaderCookie = "cxsparse"
+
+// Cookie represents the Vhd header or Vhd footer cookie.
+// Footer Cookie are used to uniquely identify the original creator of the hard disk
+// image. The values are case-sensitive. Header Cookie holds the value "cxsparse".
+type Cookie struct {
+ Data []byte
+ isHeader bool
+}
+
+// CreateNewVhdCookie creates a new VhdCookie, the new instance's Data will be simply
+// reference to the byte slice data (i.e. this function will not create a copy)
+//
+func CreateNewVhdCookie(isHeader bool, data []byte) *Cookie {
+ return &Cookie{isHeader: isHeader, Data: data}
+}
+
+// CreateFooterCookie creates a VhdCookie representing vhd footer cookie
+//
+func CreateFooterCookie() *Cookie {
+ return CreateNewVhdCookie(false, []byte(VhdFooterCookie))
+}
+
+// CreateHeaderCookie creates a VhdCookie representing vhd header cookie
+//
+func CreateHeaderCookie() *Cookie {
+ return CreateNewVhdCookie(true, []byte(VhdHeaderCookie))
+}
+
+// IsValid checks whether this this instance's internal cookie string is valid.
+//
+func (c *Cookie) IsValid() bool {
+ if c.isHeader {
+ return bytes.Equal(c.Data, []byte(VhdHeaderCookie))
+ }
+
+ return bytes.Equal(c.Data, []byte(VhdFooterCookie))
+}
+
+// CreateCopy creates a copy of this instance
+//
+func (c *Cookie) CreateCopy() *Cookie {
+ cp := &Cookie{isHeader: c.isHeader}
+ cp.Data = make([]byte, len(c.Data))
+ copy(cp.Data, c.Data)
+ return cp
+}
+
+// Equal returns true if this and other points to the same instance or contents of field
+// values of two are same.
+//
+func (c *Cookie) Equal(other *Cookie) bool {
+ if other == nil {
+ return false
+ }
+
+ if c == other {
+ return true
+ }
+
+ return c.isHeader == other.isHeader && bytes.Equal(c.Data, other.Data)
+}
+
+// String returns the string representation of this range, this satisfies stringer interface.
+//
+func (c *Cookie) String() string {
+ return string(c.Data)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdTimeStamp.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdTimeStamp.go
new file mode 100644
index 00000000000..7878d557253
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdTimeStamp.go
@@ -0,0 +1,42 @@
+package vhdcore
+
+import (
+ "log"
+ "time"
+)
+
+// TimeStamp represents the the creation time of a hard disk image. This is the number
+// of seconds since vhd base time which is January 1, 2000 12:00:00 AM in UTC/GMT.
+// The disk creation time is stored in the vhd footer in big-endian format.
+//
+type TimeStamp struct {
+ TotalSeconds uint32
+}
+
+// NewVhdTimeStamp creates new VhdTimeStamp with creation time as dateTime. This function
+// will panic if the given datetime is before the vhd base time.
+//
+func NewVhdTimeStamp(dateTime *time.Time) *TimeStamp {
+ vhdBaseTime := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
+ if !dateTime.After(vhdBaseTime) {
+ log.Panicf("DateTime must be after Base Vhd Time: %v", dateTime)
+ }
+
+ return &TimeStamp{
+ TotalSeconds: uint32(dateTime.Sub(vhdBaseTime).Seconds()),
+ }
+}
+
+// NewVhdTimeStampFromSeconds creates new VhdTimeStamp, creation time is calculated by adding
+// given total seconds with the vhd base time.
+//
+func NewVhdTimeStampFromSeconds(totalSeconds uint32) *TimeStamp {
+ return &TimeStamp{TotalSeconds: totalSeconds}
+}
+
+// ToDateTime returns the time.Time representation of this instance.
+//
+func (v *TimeStamp) ToDateTime() time.Time {
+ vhdBaseTime := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
+ return vhdBaseTime.Add(time.Duration(v.TotalSeconds) * time.Second)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile/vhdFile.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile/vhdFile.go
new file mode 100644
index 00000000000..bac323d94c8
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile/vhdFile.go
@@ -0,0 +1,93 @@
+package vhdfile
+
+import (
+ "fmt"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/bat"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/block"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/header"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// VhdFile represents a VHD.
+//
+type VhdFile struct {
+ // Footer represents the disk's footer.
+ Footer *footer.Footer
+ // Header represents the disk's header, this field is nil for fixed VHD.
+ // Only Dynamic and Differencing disk has header.make
+
+ Header *header.Header
+ // BlockAllocationTable represents the table holding absolute offset to the first sector
+ // of blocks in the disk. Only Dynamic and Differencing disk has BAT.
+ BlockAllocationTable *bat.BlockAllocationTable
+ // VhdReader is the reader that can be used to read the disk.
+ VhdReader *reader.VhdReader
+ // Parent represents the parent VHD of Differencing disk, this field is nil for fixed
+ // and dynamic disk.
+ Parent *VhdFile
+}
+
+// GetDiskType returns the type of the disk. Possible values are DiskTypeFixed, DiskTypeDynamic
+// and DiskTypeDifferencing.
+//
+func (f *VhdFile) GetDiskType() footer.DiskType {
+ return f.Footer.DiskType
+}
+
+// GetBlockFactory returns a BlockFactory instance that can be used to create Block instances
+// that represents blocks in the disk.
+//
+func (f *VhdFile) GetBlockFactory() (block.Factory, error) {
+ params := &block.FactoryParams{
+ VhdHeader: f.Header,
+ VhdFooter: f.Footer,
+ VhdReader: f.VhdReader,
+ }
+
+ switch f.GetDiskType() {
+ case footer.DiskTypeFixed:
+ return block.NewFixedDiskBlockFactoryWithDefaultBlockSize(params), nil
+
+ case footer.DiskTypeDynamic:
+ params.BlockAllocationTable = f.BlockAllocationTable
+ return block.NewDynamicDiskFactory(params), nil
+
+ case footer.DiskTypeDifferencing:
+ params.BlockAllocationTable = f.BlockAllocationTable
+ parentVhdFile := f.Parent
+ if parentVhdFile.GetDiskType() == footer.DiskTypeFixed {
+ params.ParentBlockFactory = block.NewFixedDiskBlockFactory(
+ &block.FactoryParams{
+ VhdHeader: parentVhdFile.Header,
+ VhdFooter: parentVhdFile.Footer,
+ VhdReader: parentVhdFile.VhdReader,
+ },
+ int64(f.Header.BlockSize)) // The block-size of parent FixedDisk and this DifferentialDisk will be same.
+
+ } else {
+ var err error
+ params.ParentBlockFactory, err = parentVhdFile.GetBlockFactory()
+ if err != nil {
+ return nil, err
+ }
+ }
+ return block.NewDifferencingDiskBlockFactory(params), nil
+ }
+
+ return nil, fmt.Errorf("Unsupported disk format: %d", f.GetDiskType())
+}
+
+// GetIdentityChain returns VHD identity chain, for differencing disk this will be a slice with
+// unique ids of this and all it's ancestor disks. For fixed and dynamic disk, this will be a
+// slice with one entry representing disk's unique id.
+//
+func (f *VhdFile) GetIdentityChain() []string {
+ ids := []string{f.Footer.UniqueID.String()}
+ for p := f.Parent; p != nil; p = p.Parent {
+ ids = append(ids, p.Footer.UniqueID.String())
+ }
+
+ return ids
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile/vhdFileFactory.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile/vhdFileFactory.go
new file mode 100644
index 00000000000..febc9db6c23
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile/vhdFileFactory.go
@@ -0,0 +1,138 @@
+package vhdfile
+
+import (
+ "os"
+ "path/filepath"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/bat"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/footer"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/header"
+ "github.com/Microsoft/azure-vhd-utils/vhdcore/reader"
+)
+
+// FileFactory is a type to create VhdFile representing VHD in the local machine
+//
+type FileFactory struct {
+ vhdDir string // Path to the directory holding VHD file
+ fd *os.File // File descriptor of the VHD file
+ parentVhdFileFactory *FileFactory // Reference to the parent VhdFileFactory if this VHD file is parent of a dynamic VHD
+ childVhdFileFactory *FileFactory // Reference to the child VhdFileFactory if this VHD file has dynamic VHD child
+}
+
+// Create creates a new VhdFile representing a VHD in the local machine located at vhdPath
+//
+func (f *FileFactory) Create(vhdPath string) (*VhdFile, error) {
+ var err error
+ if f.fd, err = os.Open(vhdPath); err != nil {
+ f.Dispose(err)
+ return nil, err
+ }
+
+ f.vhdDir = filepath.Dir(vhdPath)
+ fStat, _ := f.fd.Stat()
+ file, err := f.CreateFromReaderAtReader(f.fd, fStat.Size())
+ if err != nil {
+ f.Dispose(err)
+ return nil, err
+ }
+
+ return file, nil
+}
+
+// CreateFromReaderAtReader creates a new VhdFile from a reader.ReadAtReader, which is a reader associated
+// with a VHD in the local machine. The parameter size is the size of the VHD in bytes
+//
+func (f *FileFactory) CreateFromReaderAtReader(r reader.ReadAtReader, size int64) (*VhdFile, error) {
+ vhdReader := reader.NewVhdReader(r, size)
+ vhdFooter, err := (footer.NewFactory(vhdReader)).Create()
+ if err != nil {
+ return nil, err
+ }
+
+ vhdFile := VhdFile{
+ Footer: vhdFooter,
+ VhdReader: vhdReader,
+ }
+
+ if vhdFooter.DiskType == footer.DiskTypeFixed {
+ return &vhdFile, nil
+ }
+
+ // Disk is an expanding type (Dynamic or differencing)
+ vhdHeader, err := (header.NewFactory(vhdReader, vhdFooter.HeaderOffset)).Create()
+ if err != nil {
+ return nil, err
+ }
+ vhdFile.Header = vhdHeader
+
+ vhdBlockAllocationTable, err := (bat.NewBlockAllocationFactory(vhdReader, vhdHeader)).Create()
+ if err != nil {
+ return nil, err
+ }
+ vhdFile.BlockAllocationTable = vhdBlockAllocationTable
+
+ if vhdFooter.DiskType == footer.DiskTypeDynamic {
+ return &vhdFile, nil
+ }
+
+ var parentPath string
+ if f.vhdDir == "." || f.vhdDir == string(os.PathSeparator) {
+ parentPath = vhdHeader.ParentPath
+ } else {
+ parentPath = filepath.Join(parentPath, vhdHeader.ParentLocators.GetRelativeParentPath())
+ }
+
+ // Insert a node in the doubly linked list of VhdFileFactory chain.
+ f.parentVhdFileFactory = &FileFactory{childVhdFileFactory: f}
+ // Set differencing disk parent VhdFile
+ vhdFile.Parent, err = f.parentVhdFileFactory.Create(parentPath)
+ if err != nil {
+ return nil, err
+ }
+
+ return &vhdFile, nil
+}
+
+// Dispose disposes this instance of VhdFileFactory and VhdFileFactory instances of parent and child
+// VHDs
+//
+func (f *FileFactory) Dispose(err error) {
+ if f.fd != nil {
+ f.fd.Close()
+ f.fd = nil
+ }
+
+ if f.parentVhdFileFactory != nil {
+ f.parentVhdFileFactory.disposeUp(err)
+ }
+
+ if f.childVhdFileFactory != nil {
+ f.childVhdFileFactory.disposeDown(err)
+ }
+}
+
+// Dispose disposes this instance of VhdFileFactory and VhdFileFactory instances of all ancestor VHDs
+//
+func (f *FileFactory) disposeUp(err error) {
+ if f.fd != nil {
+ f.fd.Close()
+ f.fd = nil
+ }
+
+ if f.parentVhdFileFactory != nil {
+ f.parentVhdFileFactory.disposeUp(err)
+ }
+}
+
+// Dispose disposes this instance of VhdFileFactory and VhdFileFactory instances of all descendant VHDs
+//
+func (f *FileFactory) disposeDown(err error) {
+ if f.fd != nil {
+ f.fd.Close()
+ f.fd = nil
+ }
+
+ if f.childVhdFileFactory != nil {
+ f.childVhdFileFactory.disposeDown(err)
+ }
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/writer/binaryWriter.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/writer/binaryWriter.go
new file mode 100644
index 00000000000..7faf312222b
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/writer/binaryWriter.go
@@ -0,0 +1,106 @@
+package writer
+
+import (
+ "encoding/binary"
+ "io"
+)
+
+// bufferSizeInBytes is the size of the buffer used by BinaryWriter
+//
+const bufferSizeInBytes = 16
+
+// BinaryWriter is the writer which can be used to write values of primitive types to a writer
+// The writer supports writing data both in little-endian or big-endian format.
+//
+type BinaryWriter struct {
+ buffer []byte
+ order binary.ByteOrder
+ to io.WriterAt
+ Size int64
+}
+
+// NewBinaryWriter creates a new instance of BinaryWriter, to is the underlying data source
+// to write to, order is the byte order used to encode the data in the source, size is the
+// length of the data source in bytes.
+//
+func NewBinaryWriter(to io.WriterAt, order binary.ByteOrder, size int64) *BinaryWriter {
+ return &BinaryWriter{
+ buffer: make([]byte, bufferSizeInBytes),
+ order: order,
+ to: to,
+ Size: size,
+ }
+}
+
+// WriteBytes writes a byte slice to the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteBytes(off int64, value []byte) {
+ w.to.WriteAt(value, off)
+}
+
+// WriteByte write a byte value to the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteByte(off int64, value byte) {
+ w.buffer[0] = value
+ w.to.WriteAt(w.buffer[:1], off)
+}
+
+// WriteBoolean write a boolean value to the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteBoolean(off int64, value bool) {
+ if value {
+ w.buffer[0] = 1
+ } else {
+ w.buffer[0] = 0
+ }
+
+ w.to.WriteAt(w.buffer[:1], off)
+}
+
+// WriteInt16 encodes an int16 and write it in the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteInt16(off int64, value int16) {
+ w.order.PutUint16(w.buffer, uint16(value))
+ w.to.WriteAt(w.buffer[:2], off)
+}
+
+// WriteUInt16 encodes an uint16 and write it in the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteUInt16(off int64, value uint16) {
+ w.order.PutUint16(w.buffer, value)
+ w.to.WriteAt(w.buffer[:2], off)
+}
+
+// WriteInt32 encodes an int32 and write it in the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteInt32(off int64, value int32) {
+ w.order.PutUint32(w.buffer, uint32(value))
+ w.to.WriteAt(w.buffer[:4], off)
+}
+
+// WriteUInt32 encodes an uint32 and write it in the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteUInt32(off int64, value uint32) {
+ w.order.PutUint32(w.buffer, value)
+ w.to.WriteAt(w.buffer[:4], off)
+}
+
+// WriteInt64 encodes an int64 and write it in the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteInt64(off int64, value int64) {
+ w.order.PutUint64(w.buffer, uint64(value))
+ w.to.WriteAt(w.buffer[:8], off)
+}
+
+// WriteUInt64 encodes an uint64 and write it in the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteUInt64(off int64, value uint64) {
+ w.order.PutUint64(w.buffer, value)
+ w.to.WriteAt(w.buffer[:8], off)
+}
+
+// WriteString writes a string to the underlying writer at offset off.
+//
+func (w *BinaryWriter) WriteString(off int64, value string) {
+ w.to.WriteAt([]byte(value), off)
+}
diff --git a/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/writer/vhdWriter.go b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/writer/vhdWriter.go
new file mode 100644
index 00000000000..754fdb67def
--- /dev/null
+++ b/vendor/github.com/Microsoft/azure-vhd-utils/vhdcore/writer/vhdWriter.go
@@ -0,0 +1,77 @@
+package writer
+
+import (
+ "encoding/binary"
+ "fmt"
+ "io"
+ "time"
+ "unsafe"
+
+ "github.com/Microsoft/azure-vhd-utils/vhdcore"
+)
+
+// VhdWriter is the writer used by various components responsible for writing header and
+// footer of the VHD.
+//
+type VhdWriter struct {
+ *BinaryWriter
+}
+
+// NewVhdWriter creates new instance of the VhdWriter, that writes to the underlying target,
+// size is the size of the target in bytes.
+//
+func NewVhdWriter(target io.WriterAt, size int64) *VhdWriter {
+ var order binary.ByteOrder
+ if isLittleEndian() {
+ order = binary.BigEndian
+ } else {
+ order = binary.LittleEndian
+ }
+ return &VhdWriter{NewBinaryWriter(target, order, size)}
+}
+
+// NewVhdWriterFromByteSlice creates a new instance of VhdWriter, that uses the given byte
+// slice as the underlying target to write to.
+//
+func NewVhdWriterFromByteSlice(b []byte) *VhdWriter {
+ return NewVhdWriter(ByteSliceWriteAt(b), int64(len(b)))
+}
+
+// WriteTimeStamp writes vhd timestamp represented by the given time to underlying source
+// starting at byte offset off.
+//
+func (r *VhdWriter) WriteTimeStamp(off int64, time *time.Time) {
+ vhdTimeStamp := vhdcore.NewVhdTimeStamp(time)
+ r.WriteUInt32(off, vhdTimeStamp.TotalSeconds)
+}
+
+// ByteSliceWriteAt is a type that satisfies io.WriteAt interface for byte slice.
+//
+type ByteSliceWriteAt []byte
+
+// WriteAt copies len(b) bytes to the byte slice starting at byte offset off. It returns the number
+// of bytes copied and an error, if any. WriteAt returns a non-nil error when n != len(b).
+//
+func (s ByteSliceWriteAt) WriteAt(b []byte, off int64) (n int, err error) {
+ if off < 0 || off > int64(len(s)) {
+ err = fmt.Errorf("Index %d is out of the boundary %d", off, len(s)-1)
+ return
+ }
+
+ n = copy(s[off:], b)
+ if n != len(b) {
+ err = fmt.Errorf("Could write only %d bytes, as source is %d bytes and destination is %d bytes", n, len(b), len(s))
+ }
+
+ return
+}
+
+// isLittleEndian returns true if the host machine is little endian, false for big endian.
+//
+func isLittleEndian() bool {
+ var i int32 = 0x01020304
+ u := unsafe.Pointer(&i)
+ pb := (*byte)(u)
+ b := *pb
+ return (b == 0x04)
+}
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/LICENSE b/vendor/github.com/openshift/azure-sdk-for-go/LICENSE
new file mode 100644
index 00000000000..af39a91e703
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright 2016 Microsoft Corporation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/README.md b/vendor/github.com/openshift/azure-sdk-for-go/storage/README.md
new file mode 100644
index 00000000000..0ab099848bb
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/README.md
@@ -0,0 +1,5 @@
+# Azure Storage SDK for Go
+
+The `github.com/Azure/azure-sdk-for-go/storage` package is used to perform operations in Azure Storage Service. To manage your storage accounts (Azure Resource Manager / ARM), use the [github.com/Azure/azure-sdk-for-go/arm/storage](../arm/storage) package. For your classic storage accounts (Azure Service Management / ASM), use [github.com/Azure/azure-sdk-for-go/management/storageservice](../management/storageservice) package.
+
+This package includes support for [Azure Storage Emulator](https://azure.microsoft.com/documentation/articles/storage-use-emulator/)
\ No newline at end of file
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/blob.go b/vendor/github.com/openshift/azure-sdk-for-go/storage/blob.go
new file mode 100644
index 00000000000..4207cfec6e7
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/blob.go
@@ -0,0 +1,1133 @@
+package storage
+
+import (
+ "bytes"
+ "encoding/xml"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// BlobStorageClient contains operations for Microsoft Azure Blob Storage
+// Service.
+type BlobStorageClient struct {
+ client Client
+}
+
+// A Container is an entry in ContainerListResponse.
+type Container struct {
+ Name string `xml:"Name"`
+ Properties ContainerProperties `xml:"Properties"`
+ // TODO (ahmetalpbalkan) Metadata
+}
+
+// ContainerProperties contains various properties of a container returned from
+// various endpoints like ListContainers.
+type ContainerProperties struct {
+ LastModified string `xml:"Last-Modified"`
+ Etag string `xml:"Etag"`
+ LeaseStatus string `xml:"LeaseStatus"`
+ LeaseState string `xml:"LeaseState"`
+ LeaseDuration string `xml:"LeaseDuration"`
+ // TODO (ahmetalpbalkan) remaining fields
+}
+
+// ContainerListResponse contains the response fields from
+// ListContainers call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179352.aspx
+type ContainerListResponse struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Prefix string `xml:"Prefix"`
+ Marker string `xml:"Marker"`
+ NextMarker string `xml:"NextMarker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Containers []Container `xml:"Containers>Container"`
+}
+
+// A Blob is an entry in BlobListResponse.
+type Blob struct {
+ Name string `xml:"Name"`
+ Properties BlobProperties `xml:"Properties"`
+ Metadata BlobMetadata `xml:"Metadata"`
+}
+
+// BlobMetadata is a set of custom name/value pairs.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179404.aspx
+type BlobMetadata map[string]string
+
+type blobMetadataEntries struct {
+ Entries []blobMetadataEntry `xml:",any"`
+}
+type blobMetadataEntry struct {
+ XMLName xml.Name
+ Value string `xml:",chardata"`
+}
+
+// UnmarshalXML converts the xml:Metadata into Metadata map
+func (bm *BlobMetadata) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+ var entries blobMetadataEntries
+ if err := d.DecodeElement(&entries, &start); err != nil {
+ return err
+ }
+ for _, entry := range entries.Entries {
+ if *bm == nil {
+ *bm = make(BlobMetadata)
+ }
+ (*bm)[strings.ToLower(entry.XMLName.Local)] = entry.Value
+ }
+ return nil
+}
+
+// MarshalXML implements the xml.Marshaler interface. It encodes
+// metadata name/value pairs as they would appear in an Azure
+// ListBlobs response.
+func (bm BlobMetadata) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {
+ entries := make([]blobMetadataEntry, 0, len(bm))
+ for k, v := range bm {
+ entries = append(entries, blobMetadataEntry{
+ XMLName: xml.Name{Local: http.CanonicalHeaderKey(k)},
+ Value: v,
+ })
+ }
+ return enc.EncodeElement(blobMetadataEntries{
+ Entries: entries,
+ }, start)
+}
+
+// BlobProperties contains various properties of a blob
+// returned in various endpoints like ListBlobs or GetBlobProperties.
+type BlobProperties struct {
+ LastModified string `xml:"Last-Modified"`
+ Etag string `xml:"Etag"`
+ ContentMD5 string `xml:"Content-MD5"`
+ ContentLength int64 `xml:"Content-Length"`
+ ContentType string `xml:"Content-Type"`
+ ContentEncoding string `xml:"Content-Encoding"`
+ CacheControl string `xml:"Cache-Control"`
+ ContentLanguage string `xml:"Cache-Language"`
+ BlobType BlobType `xml:"x-ms-blob-blob-type"`
+ SequenceNumber int64 `xml:"x-ms-blob-sequence-number"`
+ CopyID string `xml:"CopyId"`
+ CopyStatus string `xml:"CopyStatus"`
+ CopySource string `xml:"CopySource"`
+ CopyProgress string `xml:"CopyProgress"`
+ CopyCompletionTime string `xml:"CopyCompletionTime"`
+ CopyStatusDescription string `xml:"CopyStatusDescription"`
+ LeaseStatus string `xml:"LeaseStatus"`
+}
+
+// BlobHeaders contains various properties of a blob and is an entry
+// in SetBlobProperties
+type BlobHeaders struct {
+ ContentMD5 string `header:"x-ms-blob-content-md5"`
+ ContentLanguage string `header:"x-ms-blob-content-language"`
+ ContentEncoding string `header:"x-ms-blob-content-encoding"`
+ ContentType string `header:"x-ms-blob-content-type"`
+ CacheControl string `header:"x-ms-blob-cache-control"`
+}
+
+// BlobListResponse contains the response fields from ListBlobs call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd135734.aspx
+type BlobListResponse struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Prefix string `xml:"Prefix"`
+ Marker string `xml:"Marker"`
+ NextMarker string `xml:"NextMarker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Blobs []Blob `xml:"Blobs>Blob"`
+
+ // BlobPrefix is used to traverse blobs as if it were a file system.
+ // It is returned if ListBlobsParameters.Delimiter is specified.
+ // The list here can be thought of as "folders" that may contain
+ // other folders or blobs.
+ BlobPrefixes []string `xml:"Blobs>BlobPrefix>Name"`
+
+ // Delimiter is used to traverse blobs as if it were a file system.
+ // It is returned if ListBlobsParameters.Delimiter is specified.
+ Delimiter string `xml:"Delimiter"`
+}
+
+// ListContainersParameters defines the set of customizable parameters to make a
+// List Containers call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179352.aspx
+type ListContainersParameters struct {
+ Prefix string
+ Marker string
+ Include string
+ MaxResults uint
+ Timeout uint
+}
+
+func (p ListContainersParameters) getParameters() url.Values {
+ out := url.Values{}
+
+ if p.Prefix != "" {
+ out.Set("prefix", p.Prefix)
+ }
+ if p.Marker != "" {
+ out.Set("marker", p.Marker)
+ }
+ if p.Include != "" {
+ out.Set("include", p.Include)
+ }
+ if p.MaxResults != 0 {
+ out.Set("maxresults", fmt.Sprintf("%v", p.MaxResults))
+ }
+ if p.Timeout != 0 {
+ out.Set("timeout", fmt.Sprintf("%v", p.Timeout))
+ }
+
+ return out
+}
+
+// ListBlobsParameters defines the set of customizable
+// parameters to make a List Blobs call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd135734.aspx
+type ListBlobsParameters struct {
+ Prefix string
+ Delimiter string
+ Marker string
+ Include string
+ MaxResults uint
+ Timeout uint
+}
+
+func (p ListBlobsParameters) getParameters() url.Values {
+ out := url.Values{}
+
+ if p.Prefix != "" {
+ out.Set("prefix", p.Prefix)
+ }
+ if p.Delimiter != "" {
+ out.Set("delimiter", p.Delimiter)
+ }
+ if p.Marker != "" {
+ out.Set("marker", p.Marker)
+ }
+ if p.Include != "" {
+ out.Set("include", p.Include)
+ }
+ if p.MaxResults != 0 {
+ out.Set("maxresults", fmt.Sprintf("%v", p.MaxResults))
+ }
+ if p.Timeout != 0 {
+ out.Set("timeout", fmt.Sprintf("%v", p.Timeout))
+ }
+
+ return out
+}
+
+// BlobType defines the type of the Azure Blob.
+type BlobType string
+
+// Types of page blobs
+const (
+ BlobTypeBlock BlobType = "BlockBlob"
+ BlobTypePage BlobType = "PageBlob"
+ BlobTypeAppend BlobType = "AppendBlob"
+)
+
+// PageWriteType defines the type updates that are going to be
+// done on the page blob.
+type PageWriteType string
+
+// Types of operations on page blobs
+const (
+ PageWriteTypeUpdate PageWriteType = "update"
+ PageWriteTypeClear PageWriteType = "clear"
+)
+
+const (
+ blobCopyStatusPending = "pending"
+ blobCopyStatusSuccess = "success"
+ blobCopyStatusAborted = "aborted"
+ blobCopyStatusFailed = "failed"
+)
+
+// BlockListType is used to filter out types of blocks in a Get Blocks List call
+// for a block blob.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179400.aspx for all
+// block types.
+type BlockListType string
+
+// Filters for listing blocks in block blobs
+const (
+ BlockListTypeAll BlockListType = "all"
+ BlockListTypeCommitted BlockListType = "committed"
+ BlockListTypeUncommitted BlockListType = "uncommitted"
+)
+
+// ContainerAccessType defines the access level to the container from a public
+// request.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179468.aspx and "x-ms-
+// blob-public-access" header.
+type ContainerAccessType string
+
+// Access options for containers
+const (
+ ContainerAccessTypePrivate ContainerAccessType = ""
+ ContainerAccessTypeBlob ContainerAccessType = "blob"
+ ContainerAccessTypeContainer ContainerAccessType = "container"
+)
+
+// Maximum sizes (per REST API) for various concepts
+const (
+ MaxBlobBlockSize = 4 * 1024 * 1024
+ MaxBlobPageSize = 4 * 1024 * 1024
+)
+
+// BlockStatus defines states a block for a block blob can
+// be in.
+type BlockStatus string
+
+// List of statuses that can be used to refer to a block in a block list
+const (
+ BlockStatusUncommitted BlockStatus = "Uncommitted"
+ BlockStatusCommitted BlockStatus = "Committed"
+ BlockStatusLatest BlockStatus = "Latest"
+)
+
+// Block is used to create Block entities for Put Block List
+// call.
+type Block struct {
+ ID string
+ Status BlockStatus
+}
+
+// BlockListResponse contains the response fields from Get Block List call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179400.aspx
+type BlockListResponse struct {
+ XMLName xml.Name `xml:"BlockList"`
+ CommittedBlocks []BlockResponse `xml:"CommittedBlocks>Block"`
+ UncommittedBlocks []BlockResponse `xml:"UncommittedBlocks>Block"`
+}
+
+// BlockResponse contains the block information returned
+// in the GetBlockListCall.
+type BlockResponse struct {
+ Name string `xml:"Name"`
+ Size int64 `xml:"Size"`
+}
+
+// GetPageRangesResponse contains the reponse fields from
+// Get Page Ranges call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/ee691973.aspx
+type GetPageRangesResponse struct {
+ XMLName xml.Name `xml:"PageList"`
+ PageList []PageRange `xml:"PageRange"`
+}
+
+// PageRange contains information about a page of a page blob from
+// Get Pages Range call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/ee691973.aspx
+type PageRange struct {
+ Start int64 `xml:"Start"`
+ End int64 `xml:"End"`
+}
+
+var (
+ errBlobCopyAborted = errors.New("storage: blob copy is aborted")
+ errBlobCopyIDMismatch = errors.New("storage: blob copy id is a mismatch")
+)
+
+// ListContainers returns the list of containers in a storage account along with
+// pagination token and other response details.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179352.aspx
+func (b BlobStorageClient) ListContainers(params ListContainersParameters) (ContainerListResponse, error) {
+ q := mergeParams(params.getParameters(), url.Values{"comp": {"list"}})
+ uri := b.client.getEndpoint(blobServiceName, "", q)
+ headers := b.client.getStandardHeaders()
+
+ var out ContainerListResponse
+ resp, err := b.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return out, err
+ }
+ defer resp.body.Close()
+
+ err = xmlUnmarshal(resp.body, &out)
+ return out, err
+}
+
+// CreateContainer creates a blob container within the storage account
+// with given name and access level. Returns error if container already exists.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179468.aspx
+func (b BlobStorageClient) CreateContainer(name string, access ContainerAccessType) error {
+ resp, err := b.createContainer(name, access)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// CreateContainerIfNotExists creates a blob container if it does not exist. Returns
+// true if container is newly created or false if container already exists.
+func (b BlobStorageClient) CreateContainerIfNotExists(name string, access ContainerAccessType) (bool, error) {
+ resp, err := b.createContainer(name, access)
+ if resp != nil {
+ defer resp.body.Close()
+ if resp.statusCode == http.StatusCreated || resp.statusCode == http.StatusConflict {
+ return resp.statusCode == http.StatusCreated, nil
+ }
+ }
+ return false, err
+}
+
+func (b BlobStorageClient) createContainer(name string, access ContainerAccessType) (*storageResponse, error) {
+ verb := "PUT"
+ uri := b.client.getEndpoint(blobServiceName, pathForContainer(name), url.Values{"restype": {"container"}})
+
+ headers := b.client.getStandardHeaders()
+ if access != "" {
+ headers["x-ms-blob-public-access"] = string(access)
+ }
+ return b.client.exec(verb, uri, headers, nil)
+}
+
+// ContainerExists returns true if a container with given name exists
+// on the storage account, otherwise returns false.
+func (b BlobStorageClient) ContainerExists(name string) (bool, error) {
+ verb := "HEAD"
+ uri := b.client.getEndpoint(blobServiceName, pathForContainer(name), url.Values{"restype": {"container"}})
+ headers := b.client.getStandardHeaders()
+
+ resp, err := b.client.exec(verb, uri, headers, nil)
+ if resp != nil {
+ defer resp.body.Close()
+ if resp.statusCode == http.StatusOK || resp.statusCode == http.StatusNotFound {
+ return resp.statusCode == http.StatusOK, nil
+ }
+ }
+ return false, err
+}
+
+// DeleteContainer deletes the container with given name on the storage
+// account. If the container does not exist returns error.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179408.aspx
+func (b BlobStorageClient) DeleteContainer(name string) error {
+ resp, err := b.deleteContainer(name)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusAccepted})
+}
+
+// DeleteContainerIfExists deletes the container with given name on the storage
+// account if it exists. Returns true if container is deleted with this call, or
+// false if the container did not exist at the time of the Delete Container
+// operation.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179408.aspx
+func (b BlobStorageClient) DeleteContainerIfExists(name string) (bool, error) {
+ resp, err := b.deleteContainer(name)
+ if resp != nil {
+ defer resp.body.Close()
+ if resp.statusCode == http.StatusAccepted || resp.statusCode == http.StatusNotFound {
+ return resp.statusCode == http.StatusAccepted, nil
+ }
+ }
+ return false, err
+}
+
+func (b BlobStorageClient) deleteContainer(name string) (*storageResponse, error) {
+ verb := "DELETE"
+ uri := b.client.getEndpoint(blobServiceName, pathForContainer(name), url.Values{"restype": {"container"}})
+
+ headers := b.client.getStandardHeaders()
+ return b.client.exec(verb, uri, headers, nil)
+}
+
+// ListBlobs returns an object that contains list of blobs in the container,
+// pagination token and other information in the response of List Blobs call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd135734.aspx
+func (b BlobStorageClient) ListBlobs(container string, params ListBlobsParameters) (BlobListResponse, error) {
+ q := mergeParams(params.getParameters(), url.Values{
+ "restype": {"container"},
+ "comp": {"list"}})
+ uri := b.client.getEndpoint(blobServiceName, pathForContainer(container), q)
+ headers := b.client.getStandardHeaders()
+
+ var out BlobListResponse
+ resp, err := b.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return out, err
+ }
+ defer resp.body.Close()
+
+ err = xmlUnmarshal(resp.body, &out)
+ return out, err
+}
+
+// BlobExists returns true if a blob with given name exists on the specified
+// container of the storage account.
+func (b BlobStorageClient) BlobExists(container, name string) (bool, error) {
+ verb := "HEAD"
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{})
+ headers := b.client.getStandardHeaders()
+ resp, err := b.client.exec(verb, uri, headers, nil)
+ if resp != nil {
+ defer resp.body.Close()
+ if resp.statusCode == http.StatusOK || resp.statusCode == http.StatusNotFound {
+ return resp.statusCode == http.StatusOK, nil
+ }
+ }
+ return false, err
+}
+
+// GetBlobURL gets the canonical URL to the blob with the specified name in the
+// specified container. This method does not create a publicly accessible URL if
+// the blob or container is private and this method does not check if the blob
+// exists.
+func (b BlobStorageClient) GetBlobURL(container, name string) string {
+ if container == "" {
+ container = "$root"
+ }
+ return b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{})
+}
+
+// GetBlob returns a stream to read the blob. Caller must call Close() the
+// reader to close on the underlying connection.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179440.aspx
+func (b BlobStorageClient) GetBlob(container, name string) (io.ReadCloser, error) {
+ resp, err := b.getBlobRange(container, name, "", nil)
+ if err != nil {
+ return nil, err
+ }
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+ return resp.body, nil
+}
+
+// GetBlobRange reads the specified range of a blob to a stream. The bytesRange
+// string must be in a format like "0-", "10-100" as defined in HTTP 1.1 spec.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179440.aspx
+func (b BlobStorageClient) GetBlobRange(container, name, bytesRange string, extraHeaders map[string]string) (io.ReadCloser, error) {
+ resp, err := b.getBlobRange(container, name, bytesRange, extraHeaders)
+ if err != nil {
+ return nil, err
+ }
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusPartialContent}); err != nil {
+ return nil, err
+ }
+ return resp.body, nil
+}
+
+func (b BlobStorageClient) getBlobRange(container, name, bytesRange string, extraHeaders map[string]string) (*storageResponse, error) {
+ verb := "GET"
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{})
+
+ headers := b.client.getStandardHeaders()
+ if bytesRange != "" {
+ headers["Range"] = fmt.Sprintf("bytes=%s", bytesRange)
+ }
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec(verb, uri, headers, nil)
+ if err != nil {
+ return nil, err
+ }
+ return resp, err
+}
+
+// GetBlobProperties provides various information about the specified
+// blob. See https://msdn.microsoft.com/en-us/library/azure/dd179394.aspx
+func (b BlobStorageClient) GetBlobProperties(container, name string) (*BlobProperties, error) {
+ verb := "HEAD"
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{})
+
+ headers := b.client.getStandardHeaders()
+ resp, err := b.client.exec(verb, uri, headers, nil)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ var contentLength int64
+ contentLengthStr := resp.headers.Get("Content-Length")
+ if contentLengthStr != "" {
+ contentLength, err = strconv.ParseInt(contentLengthStr, 0, 64)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ var sequenceNum int64
+ sequenceNumStr := resp.headers.Get("x-ms-blob-sequence-number")
+ if sequenceNumStr != "" {
+ sequenceNum, err = strconv.ParseInt(sequenceNumStr, 0, 64)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return &BlobProperties{
+ LastModified: resp.headers.Get("Last-Modified"),
+ Etag: resp.headers.Get("Etag"),
+ ContentMD5: resp.headers.Get("Content-MD5"),
+ ContentLength: contentLength,
+ ContentEncoding: resp.headers.Get("Content-Encoding"),
+ ContentType: resp.headers.Get("Content-Type"),
+ CacheControl: resp.headers.Get("Cache-Control"),
+ ContentLanguage: resp.headers.Get("Content-Language"),
+ SequenceNumber: sequenceNum,
+ CopyCompletionTime: resp.headers.Get("x-ms-copy-completion-time"),
+ CopyStatusDescription: resp.headers.Get("x-ms-copy-status-description"),
+ CopyID: resp.headers.Get("x-ms-copy-id"),
+ CopyProgress: resp.headers.Get("x-ms-copy-progress"),
+ CopySource: resp.headers.Get("x-ms-copy-source"),
+ CopyStatus: resp.headers.Get("x-ms-copy-status"),
+ BlobType: BlobType(resp.headers.Get("x-ms-blob-type")),
+ LeaseStatus: resp.headers.Get("x-ms-lease-status"),
+ }, nil
+}
+
+// SetBlobProperties replaces the BlobHeaders for the specified blob.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetBlobProperties. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/ee691966.aspx
+func (b BlobStorageClient) SetBlobProperties(container, name string, blobHeaders BlobHeaders) error {
+ params := url.Values{"comp": {"properties"}}
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), params)
+ headers := b.client.getStandardHeaders()
+
+ extraHeaders := headersFromStruct(blobHeaders)
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusOK})
+}
+
+// SetBlobMetadata replaces the metadata for the specified blob.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetBlobMetadata. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+func (b BlobStorageClient) SetBlobMetadata(container, name string, metadata map[string]string, extraHeaders map[string]string) error {
+ params := url.Values{"comp": {"metadata"}}
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), params)
+ headers := b.client.getStandardHeaders()
+ for k, v := range metadata {
+ headers[userDefinedMetadataHeaderPrefix+k] = v
+ }
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusOK})
+}
+
+// GetBlobMetadata returns all user-defined metadata for the specified blob.
+//
+// All metadata keys will be returned in lower case. (HTTP header
+// names are case-insensitive.)
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+func (b BlobStorageClient) GetBlobMetadata(container, name string) (map[string]string, error) {
+ params := url.Values{"comp": {"metadata"}}
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), params)
+ headers := b.client.getStandardHeaders()
+
+ resp, err := b.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ metadata := make(map[string]string)
+ for k, v := range resp.headers {
+ // Can't trust CanonicalHeaderKey() to munge case
+ // reliably. "_" is allowed in identifiers:
+ // https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+ // https://msdn.microsoft.com/library/aa664670(VS.71).aspx
+ // http://tools.ietf.org/html/rfc7230#section-3.2
+ // ...but "_" is considered invalid by
+ // CanonicalMIMEHeaderKey in
+ // https://golang.org/src/net/textproto/reader.go?s=14615:14659#L542
+ // so k can be "X-Ms-Meta-Foo" or "x-ms-meta-foo_bar".
+ k = strings.ToLower(k)
+ if len(v) == 0 || !strings.HasPrefix(k, strings.ToLower(userDefinedMetadataHeaderPrefix)) {
+ continue
+ }
+ // metadata["foo"] = content of the last X-Ms-Meta-Foo header
+ k = k[len(userDefinedMetadataHeaderPrefix):]
+ metadata[k] = v[len(v)-1]
+ }
+ return metadata, nil
+}
+
+// CreateBlockBlob initializes an empty block blob with no blocks.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179451.aspx
+func (b BlobStorageClient) CreateBlockBlob(container, name string) error {
+ return b.CreateBlockBlobFromReader(container, name, 0, nil, nil)
+}
+
+// CreateBlockBlobFromReader initializes a block blob using data from
+// reader. Size must be the number of bytes read from reader. To
+// create an empty blob, use size==0 and reader==nil.
+//
+// The API rejects requests with size > 64 MiB (but this limit is not
+// checked by the SDK). To write a larger blob, use CreateBlockBlob,
+// PutBlock, and PutBlockList.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179451.aspx
+func (b BlobStorageClient) CreateBlockBlobFromReader(container, name string, size uint64, blob io.Reader, extraHeaders map[string]string) error {
+ path := fmt.Sprintf("%s/%s", container, name)
+ uri := b.client.getEndpoint(blobServiceName, path, url.Values{})
+ headers := b.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypeBlock)
+ headers["Content-Length"] = fmt.Sprintf("%d", size)
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec("PUT", uri, headers, blob)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// PutBlock saves the given data chunk to the specified block blob with
+// given ID.
+//
+// The API rejects chunks larger than 4 MiB (but this limit is not
+// checked by the SDK).
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd135726.aspx
+func (b BlobStorageClient) PutBlock(container, name, blockID string, chunk []byte) error {
+ return b.PutBlockWithLength(container, name, blockID, uint64(len(chunk)), bytes.NewReader(chunk), nil)
+}
+
+// PutBlockWithLength saves the given data stream of exactly specified size to
+// the block blob with given ID. It is an alternative to PutBlocks where data
+// comes as stream but the length is known in advance.
+//
+// The API rejects requests with size > 4 MiB (but this limit is not
+// checked by the SDK).
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd135726.aspx
+func (b BlobStorageClient) PutBlockWithLength(container, name, blockID string, size uint64, blob io.Reader, extraHeaders map[string]string) error {
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{"comp": {"block"}, "blockid": {blockID}})
+ headers := b.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypeBlock)
+ headers["Content-Length"] = fmt.Sprintf("%v", size)
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec("PUT", uri, headers, blob)
+ if err != nil {
+ return err
+ }
+
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// PutBlockList saves list of blocks to the specified block blob.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179467.aspx
+func (b BlobStorageClient) PutBlockList(container, name string, blocks []Block) error {
+ blockListXML := prepareBlockListRequest(blocks)
+
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{"comp": {"blocklist"}})
+ headers := b.client.getStandardHeaders()
+ headers["Content-Length"] = fmt.Sprintf("%v", len(blockListXML))
+
+ resp, err := b.client.exec("PUT", uri, headers, strings.NewReader(blockListXML))
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// GetBlockList retrieves list of blocks in the specified block blob.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179400.aspx
+func (b BlobStorageClient) GetBlockList(container, name string, blockType BlockListType) (BlockListResponse, error) {
+ params := url.Values{"comp": {"blocklist"}, "blocklisttype": {string(blockType)}}
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), params)
+ headers := b.client.getStandardHeaders()
+
+ var out BlockListResponse
+ resp, err := b.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return out, err
+ }
+ defer resp.body.Close()
+
+ err = xmlUnmarshal(resp.body, &out)
+ return out, err
+}
+
+// PutPageBlob initializes an empty page blob with specified name and maximum
+// size in bytes (size must be aligned to a 512-byte boundary). A page blob must
+// be created using this method before writing pages.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179451.aspx
+func (b BlobStorageClient) PutPageBlob(container, name string, size int64, extraHeaders map[string]string) error {
+ path := fmt.Sprintf("%s/%s", container, name)
+ uri := b.client.getEndpoint(blobServiceName, path, url.Values{})
+ headers := b.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypePage)
+ headers["x-ms-blob-content-length"] = fmt.Sprintf("%v", size)
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// PutPage writes a range of pages to a page blob or clears the given range.
+// In case of 'clear' writes, given chunk is discarded. Ranges must be aligned
+// with 512-byte boundaries and chunk must be of size multiplies by 512.
+//
+// See https://msdn.microsoft.com/en-us/library/ee691975.aspx
+func (b BlobStorageClient) PutPage(container, name string, startByte, endByte int64, writeType PageWriteType, chunk []byte, extraHeaders map[string]string) error {
+ path := fmt.Sprintf("%s/%s", container, name)
+ uri := b.client.getEndpoint(blobServiceName, path, url.Values{"comp": {"page"}})
+ headers := b.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypePage)
+ headers["x-ms-page-write"] = string(writeType)
+ headers["x-ms-range"] = fmt.Sprintf("bytes=%v-%v", startByte, endByte)
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+ var contentLength int64
+ var data io.Reader
+ if writeType == PageWriteTypeClear {
+ contentLength = 0
+ data = bytes.NewReader([]byte{})
+ } else {
+ contentLength = int64(len(chunk))
+ data = bytes.NewReader(chunk)
+ }
+ headers["Content-Length"] = fmt.Sprintf("%v", contentLength)
+
+ resp, err := b.client.exec("PUT", uri, headers, data)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// GetPageRanges returns the list of valid page ranges for a page blob.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/ee691973.aspx
+func (b BlobStorageClient) GetPageRanges(container, name string) (GetPageRangesResponse, error) {
+ path := fmt.Sprintf("%s/%s", container, name)
+ uri := b.client.getEndpoint(blobServiceName, path, url.Values{"comp": {"pagelist"}})
+ headers := b.client.getStandardHeaders()
+
+ var out GetPageRangesResponse
+ resp, err := b.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return out, err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return out, err
+ }
+ err = xmlUnmarshal(resp.body, &out)
+ return out, err
+}
+
+// PutAppendBlob initializes an empty append blob with specified name. An
+// append blob must be created using this method before appending blocks.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179451.aspx
+func (b BlobStorageClient) PutAppendBlob(container, name string, extraHeaders map[string]string) error {
+ path := fmt.Sprintf("%s/%s", container, name)
+ uri := b.client.getEndpoint(blobServiceName, path, url.Values{})
+ headers := b.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypeAppend)
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// AppendBlock appends a block to an append blob.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/mt427365.aspx
+func (b BlobStorageClient) AppendBlock(container, name string, chunk []byte, extraHeaders map[string]string) error {
+ path := fmt.Sprintf("%s/%s", container, name)
+ uri := b.client.getEndpoint(blobServiceName, path, url.Values{"comp": {"appendblock"}})
+ headers := b.client.getStandardHeaders()
+ headers["x-ms-blob-type"] = string(BlobTypeAppend)
+ headers["Content-Length"] = fmt.Sprintf("%v", len(chunk))
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := b.client.exec("PUT", uri, headers, bytes.NewReader(chunk))
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// CopyBlob starts a blob copy operation and waits for the operation to
+// complete. sourceBlob parameter must be a canonical URL to the blob (can be
+// obtained using GetBlobURL method.) There is no SLA on blob copy and therefore
+// this helper method works faster on smaller files.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd894037.aspx
+func (b BlobStorageClient) CopyBlob(container, name, sourceBlob string) error {
+ copyID, err := b.startBlobCopy(container, name, sourceBlob)
+ if err != nil {
+ return err
+ }
+
+ return b.waitForBlobCopy(container, name, copyID)
+}
+
+func (b BlobStorageClient) startBlobCopy(container, name, sourceBlob string) (string, error) {
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{})
+
+ headers := b.client.getStandardHeaders()
+ headers["x-ms-copy-source"] = sourceBlob
+
+ resp, err := b.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return "", err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusAccepted, http.StatusCreated}); err != nil {
+ return "", err
+ }
+
+ copyID := resp.headers.Get("x-ms-copy-id")
+ if copyID == "" {
+ return "", errors.New("Got empty copy id header")
+ }
+ return copyID, nil
+}
+
+func (b BlobStorageClient) waitForBlobCopy(container, name, copyID string) error {
+ for {
+ props, err := b.GetBlobProperties(container, name)
+ if err != nil {
+ return err
+ }
+
+ if props.CopyID != copyID {
+ return errBlobCopyIDMismatch
+ }
+
+ switch props.CopyStatus {
+ case blobCopyStatusSuccess:
+ return nil
+ case blobCopyStatusPending:
+ continue
+ case blobCopyStatusAborted:
+ return errBlobCopyAborted
+ case blobCopyStatusFailed:
+ return fmt.Errorf("storage: blob copy failed. Id=%s Description=%s", props.CopyID, props.CopyStatusDescription)
+ default:
+ return fmt.Errorf("storage: unhandled blob copy status: '%s'", props.CopyStatus)
+ }
+ }
+}
+
+// DeleteBlob deletes the given blob from the specified container.
+// If the blob does not exists at the time of the Delete Blob operation, it
+// returns error. See https://msdn.microsoft.com/en-us/library/azure/dd179413.aspx
+func (b BlobStorageClient) DeleteBlob(container, name string, extraHeaders map[string]string) error {
+ resp, err := b.deleteBlob(container, name, extraHeaders)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusAccepted})
+}
+
+// DeleteBlobIfExists deletes the given blob from the specified container If the
+// blob is deleted with this call, returns true. Otherwise returns false.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179413.aspx
+func (b BlobStorageClient) DeleteBlobIfExists(container, name string, extraHeaders map[string]string) (bool, error) {
+ resp, err := b.deleteBlob(container, name, extraHeaders)
+ if resp != nil && (resp.statusCode == http.StatusAccepted || resp.statusCode == http.StatusNotFound) {
+ return resp.statusCode == http.StatusAccepted, nil
+ }
+ defer resp.body.Close()
+ return false, err
+}
+
+func (b BlobStorageClient) deleteBlob(container, name string, extraHeaders map[string]string) (*storageResponse, error) {
+ verb := "DELETE"
+ uri := b.client.getEndpoint(blobServiceName, pathForBlob(container, name), url.Values{})
+ headers := b.client.getStandardHeaders()
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ return b.client.exec(verb, uri, headers, nil)
+}
+
+// helper method to construct the path to a container given its name
+func pathForContainer(name string) string {
+ return fmt.Sprintf("/%s", name)
+}
+
+// helper method to construct the path to a blob given its container and blob
+// name
+func pathForBlob(container, name string) string {
+ return fmt.Sprintf("/%s/%s", container, name)
+}
+
+// GetBlobSASURI creates an URL to the specified blob which contains the Shared
+// Access Signature with specified permissions and expiration time.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/ee395415.aspx
+func (b BlobStorageClient) GetBlobSASURI(container, name string, expiry time.Time, permissions string) (string, error) {
+ var (
+ signedPermissions = permissions
+ blobURL = b.GetBlobURL(container, name)
+ )
+ canonicalizedResource, err := b.client.buildCanonicalizedResource(blobURL)
+
+ if err != nil {
+ return "", err
+ }
+
+ // "The canonicalizedresouce portion of the string is a canonical path to the signed resource.
+ // It must include the service name (blob, table, queue or file) for version 2015-02-21 or
+ // later, the storage account name, and the resource name, and must be URL-decoded.
+ // -- https://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
+
+ // We need to replace + with %2b first to avoid being treated as a space (which is correct for query strings, but not the path component).
+ canonicalizedResource = strings.Replace(canonicalizedResource, "+", "%2b", -1)
+
+ canonicalizedResource, err = url.QueryUnescape(canonicalizedResource)
+ if err != nil {
+ return "", err
+ }
+
+ signedExpiry := expiry.UTC().Format(time.RFC3339)
+ signedResource := "b"
+
+ stringToSign, err := blobSASStringToSign(b.client.apiVersion, canonicalizedResource, signedExpiry, signedPermissions)
+ if err != nil {
+ return "", err
+ }
+
+ sig := b.client.computeHmac256(stringToSign)
+ sasParams := url.Values{
+ "sv": {b.client.apiVersion},
+ "se": {signedExpiry},
+ "sr": {signedResource},
+ "sp": {signedPermissions},
+ "sig": {sig},
+ }
+
+ sasURL, err := url.Parse(blobURL)
+ if err != nil {
+ return "", err
+ }
+ sasURL.RawQuery = sasParams.Encode()
+ return sasURL.String(), nil
+}
+
+func blobSASStringToSign(signedVersion, canonicalizedResource, signedExpiry, signedPermissions string) (string, error) {
+ var signedStart, signedIdentifier, rscc, rscd, rsce, rscl, rsct string
+
+ if signedVersion >= "2015-02-21" {
+ canonicalizedResource = "/blob" + canonicalizedResource
+ }
+
+ // reference: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
+ if signedVersion >= "2013-08-15" {
+ return fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s", signedPermissions, signedStart, signedExpiry, canonicalizedResource, signedIdentifier, signedVersion, rscc, rscd, rsce, rscl, rsct), nil
+ }
+ return "", errors.New("storage: not implemented SAS for versions earlier than 2013-08-15")
+}
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/client.go b/vendor/github.com/openshift/azure-sdk-for-go/storage/client.go
new file mode 100644
index 00000000000..2816e03ec6c
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/client.go
@@ -0,0 +1,551 @@
+// Package storage provides clients for Microsoft Azure Storage Services.
+package storage
+
+import (
+ "bytes"
+ "encoding/base64"
+ "encoding/json"
+ "encoding/xml"
+ "errors"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+)
+
+const (
+ // DefaultBaseURL is the domain name used for storage requests when a
+ // default client is created.
+ DefaultBaseURL = "core.windows.net"
+
+ // DefaultAPIVersion is the Azure Storage API version string used when a
+ // basic client is created.
+ DefaultAPIVersion = "2015-02-21"
+
+ defaultUseHTTPS = true
+
+ // StorageEmulatorAccountName is the fixed storage account used by Azure Storage Emulator
+ StorageEmulatorAccountName = "devstoreaccount1"
+
+ // StorageEmulatorAccountKey is the the fixed storage account used by Azure Storage Emulator
+ StorageEmulatorAccountKey = "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw=="
+
+ blobServiceName = "blob"
+ tableServiceName = "table"
+ queueServiceName = "queue"
+ fileServiceName = "file"
+
+ storageEmulatorBlob = "127.0.0.1:10000"
+ storageEmulatorTable = "127.0.0.1:10002"
+ storageEmulatorQueue = "127.0.0.1:10001"
+)
+
+// Client is the object that needs to be constructed to perform
+// operations on the storage account.
+type Client struct {
+ // HTTPClient is the http.Client used to initiate API
+ // requests. If it is nil, http.DefaultClient is used.
+ HTTPClient *http.Client
+
+ accountName string
+ accountKey []byte
+ useHTTPS bool
+ baseURL string
+ apiVersion string
+}
+
+type storageResponse struct {
+ statusCode int
+ headers http.Header
+ body io.ReadCloser
+}
+
+type odataResponse struct {
+ storageResponse
+ odata odataErrorMessage
+}
+
+// AzureStorageServiceError contains fields of the error response from
+// Azure Storage Service REST API. See https://msdn.microsoft.com/en-us/library/azure/dd179382.aspx
+// Some fields might be specific to certain calls.
+type AzureStorageServiceError struct {
+ Code string `xml:"Code"`
+ Message string `xml:"Message"`
+ AuthenticationErrorDetail string `xml:"AuthenticationErrorDetail"`
+ QueryParameterName string `xml:"QueryParameterName"`
+ QueryParameterValue string `xml:"QueryParameterValue"`
+ Reason string `xml:"Reason"`
+ StatusCode int
+ RequestID string
+}
+
+type odataErrorMessageMessage struct {
+ Lang string `json:"lang"`
+ Value string `json:"value"`
+}
+
+type odataErrorMessageInternal struct {
+ Code string `json:"code"`
+ Message odataErrorMessageMessage `json:"message"`
+}
+
+type odataErrorMessage struct {
+ Err odataErrorMessageInternal `json:"odata.error"`
+}
+
+// UnexpectedStatusCodeError is returned when a storage service responds with neither an error
+// nor with an HTTP status code indicating success.
+type UnexpectedStatusCodeError struct {
+ allowed []int
+ got int
+}
+
+func (e UnexpectedStatusCodeError) Error() string {
+ s := func(i int) string { return fmt.Sprintf("%d %s", i, http.StatusText(i)) }
+
+ got := s(e.got)
+ expected := []string{}
+ for _, v := range e.allowed {
+ expected = append(expected, s(v))
+ }
+ return fmt.Sprintf("storage: status code from service response is %s; was expecting %s", got, strings.Join(expected, " or "))
+}
+
+// Got is the actual status code returned by Azure.
+func (e UnexpectedStatusCodeError) Got() int {
+ return e.got
+}
+
+// NewBasicClient constructs a Client with given storage service name and
+// key.
+func NewBasicClient(accountName, accountKey string) (Client, error) {
+ if accountName == StorageEmulatorAccountName {
+ return NewEmulatorClient()
+ }
+ return NewClient(accountName, accountKey, DefaultBaseURL, DefaultAPIVersion, defaultUseHTTPS)
+}
+
+//NewEmulatorClient contructs a Client intended to only work with Azure
+//Storage Emulator
+func NewEmulatorClient() (Client, error) {
+ return NewClient(StorageEmulatorAccountName, StorageEmulatorAccountKey, DefaultBaseURL, DefaultAPIVersion, false)
+}
+
+// NewClient constructs a Client. This should be used if the caller wants
+// to specify whether to use HTTPS, a specific REST API version or a custom
+// storage endpoint than Azure Public Cloud.
+func NewClient(accountName, accountKey, blobServiceBaseURL, apiVersion string, useHTTPS bool) (Client, error) {
+ var c Client
+ if accountName == "" {
+ return c, fmt.Errorf("azure: account name required")
+ } else if accountKey == "" {
+ return c, fmt.Errorf("azure: account key required")
+ } else if blobServiceBaseURL == "" {
+ return c, fmt.Errorf("azure: base storage service url required")
+ }
+
+ key, err := base64.StdEncoding.DecodeString(accountKey)
+ if err != nil {
+ return c, fmt.Errorf("azure: malformed storage account key: %v", err)
+ }
+
+ return Client{
+ accountName: accountName,
+ accountKey: key,
+ useHTTPS: useHTTPS,
+ baseURL: blobServiceBaseURL,
+ apiVersion: apiVersion,
+ }, nil
+}
+
+func (c Client) getBaseURL(service string) string {
+ scheme := "http"
+ if c.useHTTPS {
+ scheme = "https"
+ }
+ host := ""
+ if c.accountName == StorageEmulatorAccountName {
+ switch service {
+ case blobServiceName:
+ host = storageEmulatorBlob
+ case tableServiceName:
+ host = storageEmulatorTable
+ case queueServiceName:
+ host = storageEmulatorQueue
+ }
+ } else {
+ host = fmt.Sprintf("%s.%s.%s", c.accountName, service, c.baseURL)
+ }
+
+ u := &url.URL{
+ Scheme: scheme,
+ Host: host}
+ return u.String()
+}
+
+func (c Client) getEndpoint(service, path string, params url.Values) string {
+ u, err := url.Parse(c.getBaseURL(service))
+ if err != nil {
+ // really should not be happening
+ panic(err)
+ }
+
+ // API doesn't accept path segments not starting with '/'
+ if !strings.HasPrefix(path, "/") {
+ path = fmt.Sprintf("/%v", path)
+ }
+
+ if c.accountName == StorageEmulatorAccountName {
+ path = fmt.Sprintf("/%v%v", StorageEmulatorAccountName, path)
+ }
+
+ u.Path = path
+ u.RawQuery = params.Encode()
+ return u.String()
+}
+
+// GetBlobService returns a BlobStorageClient which can operate on the blob
+// service of the storage account.
+func (c Client) GetBlobService() BlobStorageClient {
+ return BlobStorageClient{c}
+}
+
+// GetQueueService returns a QueueServiceClient which can operate on the queue
+// service of the storage account.
+func (c Client) GetQueueService() QueueServiceClient {
+ return QueueServiceClient{c}
+}
+
+// GetTableService returns a TableServiceClient which can operate on the table
+// service of the storage account.
+func (c Client) GetTableService() TableServiceClient {
+ return TableServiceClient{c}
+}
+
+// GetFileService returns a FileServiceClient which can operate on the file
+// service of the storage account.
+func (c Client) GetFileService() FileServiceClient {
+ return FileServiceClient{c}
+}
+
+func (c Client) createAuthorizationHeader(canonicalizedString string) string {
+ signature := c.computeHmac256(canonicalizedString)
+ return fmt.Sprintf("%s %s:%s", "SharedKey", c.getCanonicalizedAccountName(), signature)
+}
+
+func (c Client) getAuthorizationHeader(verb, url string, headers map[string]string) (string, error) {
+ canonicalizedResource, err := c.buildCanonicalizedResource(url)
+ if err != nil {
+ return "", err
+ }
+
+ canonicalizedString := c.buildCanonicalizedString(verb, headers, canonicalizedResource)
+ return c.createAuthorizationHeader(canonicalizedString), nil
+}
+
+func (c Client) getStandardHeaders() map[string]string {
+ return map[string]string{
+ "x-ms-version": c.apiVersion,
+ "x-ms-date": currentTimeRfc1123Formatted(),
+ }
+}
+
+func (c Client) getCanonicalizedAccountName() string {
+ // since we may be trying to access a secondary storage account, we need to
+ // remove the -secondary part of the storage name
+ return strings.TrimSuffix(c.accountName, "-secondary")
+}
+
+func (c Client) buildCanonicalizedHeader(headers map[string]string) string {
+ cm := make(map[string]string)
+
+ for k, v := range headers {
+ headerName := strings.TrimSpace(strings.ToLower(k))
+ match, _ := regexp.MatchString("x-ms-", headerName)
+ if match {
+ cm[headerName] = v
+ }
+ }
+
+ if len(cm) == 0 {
+ return ""
+ }
+
+ keys := make([]string, 0, len(cm))
+ for key := range cm {
+ keys = append(keys, key)
+ }
+
+ sort.Strings(keys)
+
+ ch := ""
+
+ for i, key := range keys {
+ if i == len(keys)-1 {
+ ch += fmt.Sprintf("%s:%s", key, cm[key])
+ } else {
+ ch += fmt.Sprintf("%s:%s\n", key, cm[key])
+ }
+ }
+ return ch
+}
+
+func (c Client) buildCanonicalizedResourceTable(uri string) (string, error) {
+ errMsg := "buildCanonicalizedResourceTable error: %s"
+ u, err := url.Parse(uri)
+ if err != nil {
+ return "", fmt.Errorf(errMsg, err.Error())
+ }
+
+ cr := "/" + c.getCanonicalizedAccountName()
+
+ if len(u.Path) > 0 {
+ cr += u.Path
+ }
+
+ return cr, nil
+}
+
+func (c Client) buildCanonicalizedResource(uri string) (string, error) {
+ errMsg := "buildCanonicalizedResource error: %s"
+ u, err := url.Parse(uri)
+ if err != nil {
+ return "", fmt.Errorf(errMsg, err.Error())
+ }
+
+ cr := "/" + c.getCanonicalizedAccountName()
+
+ if len(u.Path) > 0 {
+ // Any portion of the CanonicalizedResource string that is derived from
+ // the resource's URI should be encoded exactly as it is in the URI.
+ // -- https://msdn.microsoft.com/en-gb/library/azure/dd179428.aspx
+ cr += u.EscapedPath()
+ }
+
+ params, err := url.ParseQuery(u.RawQuery)
+ if err != nil {
+ return "", fmt.Errorf(errMsg, err.Error())
+ }
+
+ if len(params) > 0 {
+ cr += "\n"
+ keys := make([]string, 0, len(params))
+ for key := range params {
+ keys = append(keys, key)
+ }
+
+ sort.Strings(keys)
+
+ for i, key := range keys {
+ if len(params[key]) > 1 {
+ sort.Strings(params[key])
+ }
+
+ if i == len(keys)-1 {
+ cr += fmt.Sprintf("%s:%s", key, strings.Join(params[key], ","))
+ } else {
+ cr += fmt.Sprintf("%s:%s\n", key, strings.Join(params[key], ","))
+ }
+ }
+ }
+
+ return cr, nil
+}
+
+func (c Client) buildCanonicalizedString(verb string, headers map[string]string, canonicalizedResource string) string {
+ contentLength := headers["Content-Length"]
+ if contentLength == "0" {
+ contentLength = ""
+ }
+ canonicalizedString := fmt.Sprintf("%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s",
+ verb,
+ headers["Content-Encoding"],
+ headers["Content-Language"],
+ contentLength,
+ headers["Content-MD5"],
+ headers["Content-Type"],
+ headers["Date"],
+ headers["If-Modified-Since"],
+ headers["If-Match"],
+ headers["If-None-Match"],
+ headers["If-Unmodified-Since"],
+ headers["Range"],
+ c.buildCanonicalizedHeader(headers),
+ canonicalizedResource)
+
+ return canonicalizedString
+}
+
+func (c Client) exec(verb, url string, headers map[string]string, body io.Reader) (*storageResponse, error) {
+ authHeader, err := c.getAuthorizationHeader(verb, url, headers)
+ if err != nil {
+ return nil, err
+ }
+ headers["Authorization"] = authHeader
+ if err != nil {
+ return nil, err
+ }
+
+ req, err := http.NewRequest(verb, url, body)
+ if err != nil {
+ return nil, errors.New("azure/storage: error creating request: " + err.Error())
+ }
+
+ if clstr, ok := headers["Content-Length"]; ok {
+ // content length header is being signed, but completely ignored by golang.
+ // instead we have to use the ContentLength property on the request struct
+ // (see https://golang.org/src/net/http/request.go?s=18140:18370#L536 and
+ // https://golang.org/src/net/http/transfer.go?s=1739:2467#L49)
+ req.ContentLength, err = strconv.ParseInt(clstr, 10, 64)
+ if err != nil {
+ return nil, err
+ }
+ }
+ for k, v := range headers {
+ req.Header.Add(k, v)
+ }
+
+ httpClient := c.HTTPClient
+ if httpClient == nil {
+ httpClient = http.DefaultClient
+ }
+ resp, err := httpClient.Do(req)
+ if err != nil {
+ return nil, err
+ }
+
+ statusCode := resp.StatusCode
+ if statusCode >= 400 && statusCode <= 505 {
+ var respBody []byte
+ respBody, err = readResponseBody(resp)
+ if err != nil {
+ return nil, err
+ }
+
+ if len(respBody) == 0 {
+ // no error in response body
+ err = fmt.Errorf("storage: service returned without a response body (%s)", resp.Status)
+ } else {
+ // response contains storage service error object, unmarshal
+ storageErr, errIn := serviceErrFromXML(respBody, resp.StatusCode, resp.Header.Get("x-ms-request-id"))
+ if err != nil { // error unmarshaling the error response
+ err = errIn
+ }
+ err = storageErr
+ }
+ return &storageResponse{
+ statusCode: resp.StatusCode,
+ headers: resp.Header,
+ body: ioutil.NopCloser(bytes.NewReader(respBody)), /* restore the body */
+ }, err
+ }
+
+ return &storageResponse{
+ statusCode: resp.StatusCode,
+ headers: resp.Header,
+ body: resp.Body}, nil
+}
+
+func (c Client) execInternalJSON(verb, url string, headers map[string]string, body io.Reader) (*odataResponse, error) {
+ req, err := http.NewRequest(verb, url, body)
+ for k, v := range headers {
+ req.Header.Add(k, v)
+ }
+
+ httpClient := c.HTTPClient
+ if httpClient == nil {
+ httpClient = http.DefaultClient
+ }
+
+ resp, err := httpClient.Do(req)
+ if err != nil {
+ return nil, err
+ }
+
+ respToRet := &odataResponse{}
+ respToRet.body = resp.Body
+ respToRet.statusCode = resp.StatusCode
+ respToRet.headers = resp.Header
+
+ statusCode := resp.StatusCode
+ if statusCode >= 400 && statusCode <= 505 {
+ var respBody []byte
+ respBody, err = readResponseBody(resp)
+ if err != nil {
+ return nil, err
+ }
+
+ if len(respBody) == 0 {
+ // no error in response body
+ err = fmt.Errorf("storage: service returned without a response body (%d)", resp.StatusCode)
+ return respToRet, err
+ }
+ // try unmarshal as odata.error json
+ err = json.Unmarshal(respBody, &respToRet.odata)
+ return respToRet, err
+ }
+
+ return respToRet, nil
+}
+
+func (c Client) createSharedKeyLite(url string, headers map[string]string) (string, error) {
+ can, err := c.buildCanonicalizedResourceTable(url)
+
+ if err != nil {
+ return "", err
+ }
+ strToSign := headers["x-ms-date"] + "\n" + can
+
+ hmac := c.computeHmac256(strToSign)
+ return fmt.Sprintf("SharedKeyLite %s:%s", c.accountName, hmac), nil
+}
+
+func (c Client) execTable(verb, url string, headers map[string]string, body io.Reader) (*odataResponse, error) {
+ var err error
+ headers["Authorization"], err = c.createSharedKeyLite(url, headers)
+ if err != nil {
+ return nil, err
+ }
+
+ return c.execInternalJSON(verb, url, headers, body)
+}
+
+func readResponseBody(resp *http.Response) ([]byte, error) {
+ defer resp.Body.Close()
+ out, err := ioutil.ReadAll(resp.Body)
+ if err == io.EOF {
+ err = nil
+ }
+ return out, err
+}
+
+func serviceErrFromXML(body []byte, statusCode int, requestID string) (AzureStorageServiceError, error) {
+ var storageErr AzureStorageServiceError
+ if err := xml.Unmarshal(body, &storageErr); err != nil {
+ return storageErr, err
+ }
+ storageErr.StatusCode = statusCode
+ storageErr.RequestID = requestID
+ return storageErr, nil
+}
+
+func (e AzureStorageServiceError) Error() string {
+ return fmt.Sprintf("storage: service returned error: StatusCode=%d, ErrorCode=%s, ErrorMessage=%s, RequestId=%s, QueryParameterName=%s, QueryParameterValue=%s",
+ e.StatusCode, e.Code, e.Message, e.RequestID, e.QueryParameterName, e.QueryParameterValue)
+}
+
+// checkRespCode returns UnexpectedStatusError if the given response code is not
+// one of the allowed status codes; otherwise nil.
+func checkRespCode(respCode int, allowed []int) error {
+ for _, v := range allowed {
+ if respCode == v {
+ return nil
+ }
+ }
+ return UnexpectedStatusCodeError{allowed, respCode}
+}
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/file.go b/vendor/github.com/openshift/azure-sdk-for-go/storage/file.go
new file mode 100644
index 00000000000..2397587c886
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/file.go
@@ -0,0 +1,352 @@
+package storage
+
+import (
+ "encoding/xml"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+)
+
+// FileServiceClient contains operations for Microsoft Azure File Service.
+type FileServiceClient struct {
+ client Client
+}
+
+// A Share is an entry in ShareListResponse.
+type Share struct {
+ Name string `xml:"Name"`
+ Properties ShareProperties `xml:"Properties"`
+}
+
+// ShareProperties contains various properties of a share returned from
+// various endpoints like ListShares.
+type ShareProperties struct {
+ LastModified string `xml:"Last-Modified"`
+ Etag string `xml:"Etag"`
+ Quota string `xml:"Quota"`
+}
+
+// ShareListResponse contains the response fields from
+// ListShares call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dn167009.aspx
+type ShareListResponse struct {
+ XMLName xml.Name `xml:"EnumerationResults"`
+ Xmlns string `xml:"xmlns,attr"`
+ Prefix string `xml:"Prefix"`
+ Marker string `xml:"Marker"`
+ NextMarker string `xml:"NextMarker"`
+ MaxResults int64 `xml:"MaxResults"`
+ Shares []Share `xml:"Shares>Share"`
+}
+
+// ListSharesParameters defines the set of customizable parameters to make a
+// List Shares call.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dn167009.aspx
+type ListSharesParameters struct {
+ Prefix string
+ Marker string
+ Include string
+ MaxResults uint
+ Timeout uint
+}
+
+// ShareHeaders contains various properties of a file and is an entry
+// in SetShareProperties
+type ShareHeaders struct {
+ Quota string `header:"x-ms-share-quota"`
+}
+
+func (p ListSharesParameters) getParameters() url.Values {
+ out := url.Values{}
+
+ if p.Prefix != "" {
+ out.Set("prefix", p.Prefix)
+ }
+ if p.Marker != "" {
+ out.Set("marker", p.Marker)
+ }
+ if p.Include != "" {
+ out.Set("include", p.Include)
+ }
+ if p.MaxResults != 0 {
+ out.Set("maxresults", fmt.Sprintf("%v", p.MaxResults))
+ }
+ if p.Timeout != 0 {
+ out.Set("timeout", fmt.Sprintf("%v", p.Timeout))
+ }
+
+ return out
+}
+
+// pathForFileShare returns the URL path segment for a File Share resource
+func pathForFileShare(name string) string {
+ return fmt.Sprintf("/%s", name)
+}
+
+// ListShares returns the list of shares in a storage account along with
+// pagination token and other response details.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179352.aspx
+func (f FileServiceClient) ListShares(params ListSharesParameters) (ShareListResponse, error) {
+ q := mergeParams(params.getParameters(), url.Values{"comp": {"list"}})
+ uri := f.client.getEndpoint(fileServiceName, "", q)
+ headers := f.client.getStandardHeaders()
+
+ var out ShareListResponse
+ resp, err := f.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return out, err
+ }
+ defer resp.body.Close()
+
+ err = xmlUnmarshal(resp.body, &out)
+ return out, err
+}
+
+// CreateShare operation creates a new share under the specified account. If the
+// share with the same name already exists, the operation fails.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dn167008.aspx
+func (f FileServiceClient) CreateShare(name string) error {
+ resp, err := f.createShare(name)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// ShareExists returns true if a share with given name exists
+// on the storage account, otherwise returns false.
+func (f FileServiceClient) ShareExists(name string) (bool, error) {
+ uri := f.client.getEndpoint(fileServiceName, pathForFileShare(name), url.Values{"restype": {"share"}})
+ headers := f.client.getStandardHeaders()
+
+ resp, err := f.client.exec("HEAD", uri, headers, nil)
+ if resp != nil {
+ defer resp.body.Close()
+ if resp.statusCode == http.StatusOK || resp.statusCode == http.StatusNotFound {
+ return resp.statusCode == http.StatusOK, nil
+ }
+ }
+ return false, err
+}
+
+// GetShareURL gets the canonical URL to the share with the specified name in the
+// specified container. This method does not create a publicly accessible URL if
+// the file is private and this method does not check if the file
+// exists.
+func (f FileServiceClient) GetShareURL(name string) string {
+ return f.client.getEndpoint(fileServiceName, pathForFileShare(name), url.Values{})
+}
+
+// CreateShareIfNotExists creates a new share under the specified account if
+// it does not exist. Returns true if container is newly created or false if
+// container already exists.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dn167008.aspx
+func (f FileServiceClient) CreateShareIfNotExists(name string) (bool, error) {
+ resp, err := f.createShare(name)
+ if resp != nil {
+ defer resp.body.Close()
+ if resp.statusCode == http.StatusCreated || resp.statusCode == http.StatusConflict {
+ return resp.statusCode == http.StatusCreated, nil
+ }
+ }
+ return false, err
+}
+
+// CreateShare creates a Azure File Share and returns its response
+func (f FileServiceClient) createShare(name string) (*storageResponse, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+ uri := f.client.getEndpoint(fileServiceName, pathForFileShare(name), url.Values{"restype": {"share"}})
+ headers := f.client.getStandardHeaders()
+ return f.client.exec("PUT", uri, headers, nil)
+}
+
+// GetShareProperties provides various information about the specified
+// file. See https://msdn.microsoft.com/en-us/library/azure/dn689099.aspx
+func (f FileServiceClient) GetShareProperties(name string) (*ShareProperties, error) {
+ uri := f.client.getEndpoint(fileServiceName, pathForFileShare(name), url.Values{"restype": {"share"}})
+
+ headers := f.client.getStandardHeaders()
+ resp, err := f.client.exec("HEAD", uri, headers, nil)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ return &ShareProperties{
+ LastModified: resp.headers.Get("Last-Modified"),
+ Etag: resp.headers.Get("Etag"),
+ Quota: resp.headers.Get("x-ms-share-quota"),
+ }, nil
+}
+
+// SetShareProperties replaces the ShareHeaders for the specified file.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by SetShareProperties. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/mt427368.aspx
+func (f FileServiceClient) SetShareProperties(name string, shareHeaders ShareHeaders) error {
+ params := url.Values{}
+ params.Set("restype", "share")
+ params.Set("comp", "properties")
+
+ uri := f.client.getEndpoint(fileServiceName, pathForFileShare(name), params)
+ headers := f.client.getStandardHeaders()
+
+ extraHeaders := headersFromStruct(shareHeaders)
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := f.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusOK})
+}
+
+// DeleteShare operation marks the specified share for deletion. The share
+// and any files contained within it are later deleted during garbage
+// collection.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dn689090.aspx
+func (f FileServiceClient) DeleteShare(name string) error {
+ resp, err := f.deleteShare(name)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusAccepted})
+}
+
+// DeleteShareIfExists operation marks the specified share for deletion if it
+// exists. The share and any files contained within it are later deleted during
+// garbage collection. Returns true if share existed and deleted with this call,
+// false otherwise.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dn689090.aspx
+func (f FileServiceClient) DeleteShareIfExists(name string) (bool, error) {
+ resp, err := f.deleteShare(name)
+ if resp != nil {
+ defer resp.body.Close()
+ if resp.statusCode == http.StatusAccepted || resp.statusCode == http.StatusNotFound {
+ return resp.statusCode == http.StatusAccepted, nil
+ }
+ }
+ return false, err
+}
+
+// deleteShare makes the call to Delete Share operation endpoint and returns
+// the response
+func (f FileServiceClient) deleteShare(name string) (*storageResponse, error) {
+ if err := f.checkForStorageEmulator(); err != nil {
+ return nil, err
+ }
+ uri := f.client.getEndpoint(fileServiceName, pathForFileShare(name), url.Values{"restype": {"share"}})
+ return f.client.exec("DELETE", uri, f.client.getStandardHeaders(), nil)
+}
+
+// SetShareMetadata replaces the metadata for the specified Share.
+//
+// Some keys may be converted to Camel-Case before sending. All keys
+// are returned in lower case by GetShareMetadata. HTTP header names
+// are case-insensitive so case munging should not matter to other
+// applications either.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+func (f FileServiceClient) SetShareMetadata(name string, metadata map[string]string, extraHeaders map[string]string) error {
+ params := url.Values{}
+ params.Set("restype", "share")
+ params.Set("comp", "metadata")
+
+ uri := f.client.getEndpoint(fileServiceName, pathForFileShare(name), params)
+ headers := f.client.getStandardHeaders()
+ for k, v := range metadata {
+ headers[userDefinedMetadataHeaderPrefix+k] = v
+ }
+
+ for k, v := range extraHeaders {
+ headers[k] = v
+ }
+
+ resp, err := f.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusOK})
+}
+
+// GetShareMetadata returns all user-defined metadata for the specified share.
+//
+// All metadata keys will be returned in lower case. (HTTP header
+// names are case-insensitive.)
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+func (f FileServiceClient) GetShareMetadata(name string) (map[string]string, error) {
+ params := url.Values{}
+ params.Set("restype", "share")
+ params.Set("comp", "metadata")
+
+ uri := f.client.getEndpoint(fileServiceName, pathForFileShare(name), params)
+ headers := f.client.getStandardHeaders()
+
+ resp, err := f.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ metadata := make(map[string]string)
+ for k, v := range resp.headers {
+ // Can't trust CanonicalHeaderKey() to munge case
+ // reliably. "_" is allowed in identifiers:
+ // https://msdn.microsoft.com/en-us/library/azure/dd179414.aspx
+ // https://msdn.microsoft.com/library/aa664670(VS.71).aspx
+ // http://tools.ietf.org/html/rfc7230#section-3.2
+ // ...but "_" is considered invalid by
+ // CanonicalMIMEHeaderKey in
+ // https://golang.org/src/net/textproto/reader.go?s=14615:14659#L542
+ // so k can be "X-Ms-Meta-Foo" or "x-ms-meta-foo_bar".
+ k = strings.ToLower(k)
+ if len(v) == 0 || !strings.HasPrefix(k, strings.ToLower(userDefinedMetadataHeaderPrefix)) {
+ continue
+ }
+ // metadata["foo"] = content of the last X-Ms-Meta-Foo header
+ k = k[len(userDefinedMetadataHeaderPrefix):]
+ metadata[k] = v[len(v)-1]
+ }
+ return metadata, nil
+}
+
+//checkForStorageEmulator determines if the client is setup for use with
+//Azure Storage Emulator, and returns a relevant error
+func (f FileServiceClient) checkForStorageEmulator() error {
+ if f.client.accountName == StorageEmulatorAccountName {
+ return fmt.Errorf("Error: File service is not currently supported by Azure Storage Emulator")
+ }
+ return nil
+}
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/queue.go b/vendor/github.com/openshift/azure-sdk-for-go/storage/queue.go
new file mode 100644
index 00000000000..3ecf4aca0d2
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/queue.go
@@ -0,0 +1,306 @@
+package storage
+
+import (
+ "encoding/xml"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+)
+
+const (
+ // casing is per Golang's http.Header canonicalizing the header names.
+ approximateMessagesCountHeader = "X-Ms-Approximate-Messages-Count"
+ userDefinedMetadataHeaderPrefix = "X-Ms-Meta-"
+)
+
+// QueueServiceClient contains operations for Microsoft Azure Queue Storage
+// Service.
+type QueueServiceClient struct {
+ client Client
+}
+
+func pathForQueue(queue string) string { return fmt.Sprintf("/%s", queue) }
+func pathForQueueMessages(queue string) string { return fmt.Sprintf("/%s/messages", queue) }
+func pathForMessage(queue, name string) string { return fmt.Sprintf("/%s/messages/%s", queue, name) }
+
+type putMessageRequest struct {
+ XMLName xml.Name `xml:"QueueMessage"`
+ MessageText string `xml:"MessageText"`
+}
+
+// PutMessageParameters is the set of options can be specified for Put Messsage
+// operation. A zero struct does not use any preferences for the request.
+type PutMessageParameters struct {
+ VisibilityTimeout int
+ MessageTTL int
+}
+
+func (p PutMessageParameters) getParameters() url.Values {
+ out := url.Values{}
+ if p.VisibilityTimeout != 0 {
+ out.Set("visibilitytimeout", strconv.Itoa(p.VisibilityTimeout))
+ }
+ if p.MessageTTL != 0 {
+ out.Set("messagettl", strconv.Itoa(p.MessageTTL))
+ }
+ return out
+}
+
+// GetMessagesParameters is the set of options can be specified for Get
+// Messsages operation. A zero struct does not use any preferences for the
+// request.
+type GetMessagesParameters struct {
+ NumOfMessages int
+ VisibilityTimeout int
+}
+
+func (p GetMessagesParameters) getParameters() url.Values {
+ out := url.Values{}
+ if p.NumOfMessages != 0 {
+ out.Set("numofmessages", strconv.Itoa(p.NumOfMessages))
+ }
+ if p.VisibilityTimeout != 0 {
+ out.Set("visibilitytimeout", strconv.Itoa(p.VisibilityTimeout))
+ }
+ return out
+}
+
+// PeekMessagesParameters is the set of options can be specified for Peek
+// Messsage operation. A zero struct does not use any preferences for the
+// request.
+type PeekMessagesParameters struct {
+ NumOfMessages int
+}
+
+func (p PeekMessagesParameters) getParameters() url.Values {
+ out := url.Values{"peekonly": {"true"}} // Required for peek operation
+ if p.NumOfMessages != 0 {
+ out.Set("numofmessages", strconv.Itoa(p.NumOfMessages))
+ }
+ return out
+}
+
+// GetMessagesResponse represents a response returned from Get Messages
+// operation.
+type GetMessagesResponse struct {
+ XMLName xml.Name `xml:"QueueMessagesList"`
+ QueueMessagesList []GetMessageResponse `xml:"QueueMessage"`
+}
+
+// GetMessageResponse represents a QueueMessage object returned from Get
+// Messages operation response.
+type GetMessageResponse struct {
+ MessageID string `xml:"MessageId"`
+ InsertionTime string `xml:"InsertionTime"`
+ ExpirationTime string `xml:"ExpirationTime"`
+ PopReceipt string `xml:"PopReceipt"`
+ TimeNextVisible string `xml:"TimeNextVisible"`
+ DequeueCount int `xml:"DequeueCount"`
+ MessageText string `xml:"MessageText"`
+}
+
+// PeekMessagesResponse represents a response returned from Get Messages
+// operation.
+type PeekMessagesResponse struct {
+ XMLName xml.Name `xml:"QueueMessagesList"`
+ QueueMessagesList []PeekMessageResponse `xml:"QueueMessage"`
+}
+
+// PeekMessageResponse represents a QueueMessage object returned from Peek
+// Messages operation response.
+type PeekMessageResponse struct {
+ MessageID string `xml:"MessageId"`
+ InsertionTime string `xml:"InsertionTime"`
+ ExpirationTime string `xml:"ExpirationTime"`
+ DequeueCount int `xml:"DequeueCount"`
+ MessageText string `xml:"MessageText"`
+}
+
+// QueueMetadataResponse represents user defined metadata and queue
+// properties on a specific queue.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179384.aspx
+type QueueMetadataResponse struct {
+ ApproximateMessageCount int
+ UserDefinedMetadata map[string]string
+}
+
+// SetMetadata operation sets user-defined metadata on the specified queue.
+// Metadata is associated with the queue as name-value pairs.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179348.aspx
+func (c QueueServiceClient) SetMetadata(name string, metadata map[string]string) error {
+ uri := c.client.getEndpoint(queueServiceName, pathForQueue(name), url.Values{"comp": []string{"metadata"}})
+ headers := c.client.getStandardHeaders()
+ for k, v := range metadata {
+ headers[userDefinedMetadataHeaderPrefix+k] = v
+ }
+
+ resp, err := c.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ return checkRespCode(resp.statusCode, []int{http.StatusNoContent})
+}
+
+// GetMetadata operation retrieves user-defined metadata and queue
+// properties on the specified queue. Metadata is associated with
+// the queue as name-values pairs.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179384.aspx
+//
+// Because the way Golang's http client (and http.Header in particular)
+// canonicalize header names, the returned metadata names would always
+// be all lower case.
+func (c QueueServiceClient) GetMetadata(name string) (QueueMetadataResponse, error) {
+ qm := QueueMetadataResponse{}
+ qm.UserDefinedMetadata = make(map[string]string)
+ uri := c.client.getEndpoint(queueServiceName, pathForQueue(name), url.Values{"comp": []string{"metadata"}})
+ headers := c.client.getStandardHeaders()
+ resp, err := c.client.exec("GET", uri, headers, nil)
+ if err != nil {
+ return qm, err
+ }
+ defer resp.body.Close()
+
+ for k, v := range resp.headers {
+ if len(v) != 1 {
+ return qm, fmt.Errorf("Unexpected number of values (%d) in response header '%s'", len(v), k)
+ }
+
+ value := v[0]
+
+ if k == approximateMessagesCountHeader {
+ qm.ApproximateMessageCount, err = strconv.Atoi(value)
+ if err != nil {
+ return qm, fmt.Errorf("Unexpected value in response header '%s': '%s' ", k, value)
+ }
+ } else if strings.HasPrefix(k, userDefinedMetadataHeaderPrefix) {
+ name := strings.TrimPrefix(k, userDefinedMetadataHeaderPrefix)
+ qm.UserDefinedMetadata[strings.ToLower(name)] = value
+ }
+ }
+
+ return qm, checkRespCode(resp.statusCode, []int{http.StatusOK})
+}
+
+// CreateQueue operation creates a queue under the given account.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179342.aspx
+func (c QueueServiceClient) CreateQueue(name string) error {
+ uri := c.client.getEndpoint(queueServiceName, pathForQueue(name), url.Values{})
+ headers := c.client.getStandardHeaders()
+ resp, err := c.client.exec("PUT", uri, headers, nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// DeleteQueue operation permanently deletes the specified queue.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179436.aspx
+func (c QueueServiceClient) DeleteQueue(name string) error {
+ uri := c.client.getEndpoint(queueServiceName, pathForQueue(name), url.Values{})
+ resp, err := c.client.exec("DELETE", uri, c.client.getStandardHeaders(), nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusNoContent})
+}
+
+// QueueExists returns true if a queue with given name exists.
+func (c QueueServiceClient) QueueExists(name string) (bool, error) {
+ uri := c.client.getEndpoint(queueServiceName, pathForQueue(name), url.Values{"comp": {"metadata"}})
+ resp, err := c.client.exec("GET", uri, c.client.getStandardHeaders(), nil)
+ if resp != nil && (resp.statusCode == http.StatusOK || resp.statusCode == http.StatusNotFound) {
+ return resp.statusCode == http.StatusOK, nil
+ }
+
+ return false, err
+}
+
+// PutMessage operation adds a new message to the back of the message queue.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179346.aspx
+func (c QueueServiceClient) PutMessage(queue string, message string, params PutMessageParameters) error {
+ uri := c.client.getEndpoint(queueServiceName, pathForQueueMessages(queue), params.getParameters())
+ req := putMessageRequest{MessageText: message}
+ body, nn, err := xmlMarshal(req)
+ if err != nil {
+ return err
+ }
+ headers := c.client.getStandardHeaders()
+ headers["Content-Length"] = strconv.Itoa(nn)
+ resp, err := c.client.exec("POST", uri, headers, body)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusCreated})
+}
+
+// ClearMessages operation deletes all messages from the specified queue.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179454.aspx
+func (c QueueServiceClient) ClearMessages(queue string) error {
+ uri := c.client.getEndpoint(queueServiceName, pathForQueueMessages(queue), url.Values{})
+ resp, err := c.client.exec("DELETE", uri, c.client.getStandardHeaders(), nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusNoContent})
+}
+
+// GetMessages operation retrieves one or more messages from the front of the
+// queue.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179474.aspx
+func (c QueueServiceClient) GetMessages(queue string, params GetMessagesParameters) (GetMessagesResponse, error) {
+ var r GetMessagesResponse
+ uri := c.client.getEndpoint(queueServiceName, pathForQueueMessages(queue), params.getParameters())
+ resp, err := c.client.exec("GET", uri, c.client.getStandardHeaders(), nil)
+ if err != nil {
+ return r, err
+ }
+ defer resp.body.Close()
+ err = xmlUnmarshal(resp.body, &r)
+ return r, err
+}
+
+// PeekMessages retrieves one or more messages from the front of the queue, but
+// does not alter the visibility of the message.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179472.aspx
+func (c QueueServiceClient) PeekMessages(queue string, params PeekMessagesParameters) (PeekMessagesResponse, error) {
+ var r PeekMessagesResponse
+ uri := c.client.getEndpoint(queueServiceName, pathForQueueMessages(queue), params.getParameters())
+ resp, err := c.client.exec("GET", uri, c.client.getStandardHeaders(), nil)
+ if err != nil {
+ return r, err
+ }
+ defer resp.body.Close()
+ err = xmlUnmarshal(resp.body, &r)
+ return r, err
+}
+
+// DeleteMessage operation deletes the specified message.
+//
+// See https://msdn.microsoft.com/en-us/library/azure/dd179347.aspx
+func (c QueueServiceClient) DeleteMessage(queue, messageID, popReceipt string) error {
+ uri := c.client.getEndpoint(queueServiceName, pathForMessage(queue, messageID), url.Values{
+ "popreceipt": {popReceipt}})
+ resp, err := c.client.exec("DELETE", uri, c.client.getStandardHeaders(), nil)
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+ return checkRespCode(resp.statusCode, []int{http.StatusNoContent})
+}
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/table.go b/vendor/github.com/openshift/azure-sdk-for-go/storage/table.go
new file mode 100644
index 00000000000..39e99750355
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/table.go
@@ -0,0 +1,129 @@
+package storage
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+)
+
+// TableServiceClient contains operations for Microsoft Azure Table Storage
+// Service.
+type TableServiceClient struct {
+ client Client
+}
+
+// AzureTable is the typedef of the Azure Table name
+type AzureTable string
+
+const (
+ tablesURIPath = "/Tables"
+)
+
+type createTableRequest struct {
+ TableName string `json:"TableName"`
+}
+
+func pathForTable(table AzureTable) string { return fmt.Sprintf("%s", table) }
+
+func (c *TableServiceClient) getStandardHeaders() map[string]string {
+ return map[string]string{
+ "x-ms-version": "2015-02-21",
+ "x-ms-date": currentTimeRfc1123Formatted(),
+ "Accept": "application/json;odata=nometadata",
+ "Accept-Charset": "UTF-8",
+ "Content-Type": "application/json",
+ }
+}
+
+// QueryTables returns the tables created in the
+// *TableServiceClient storage account.
+func (c *TableServiceClient) QueryTables() ([]AzureTable, error) {
+ uri := c.client.getEndpoint(tableServiceName, tablesURIPath, url.Values{})
+
+ headers := c.getStandardHeaders()
+ headers["Content-Length"] = "0"
+
+ resp, err := c.client.execTable("GET", uri, headers, nil)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return nil, err
+ }
+
+ buf := new(bytes.Buffer)
+ buf.ReadFrom(resp.body)
+
+ var respArray queryTablesResponse
+ if err := json.Unmarshal(buf.Bytes(), &respArray); err != nil {
+ return nil, err
+ }
+
+ s := make([]AzureTable, len(respArray.TableName))
+ for i, elem := range respArray.TableName {
+ s[i] = AzureTable(elem.TableName)
+ }
+
+ return s, nil
+}
+
+// CreateTable creates the table given the specific
+// name. This function fails if the name is not compliant
+// with the specification or the tables already exists.
+func (c *TableServiceClient) CreateTable(table AzureTable) error {
+ uri := c.client.getEndpoint(tableServiceName, tablesURIPath, url.Values{})
+
+ headers := c.getStandardHeaders()
+
+ req := createTableRequest{TableName: string(table)}
+ buf := new(bytes.Buffer)
+
+ if err := json.NewEncoder(buf).Encode(req); err != nil {
+ return err
+ }
+
+ headers["Content-Length"] = fmt.Sprintf("%d", buf.Len())
+
+ resp, err := c.client.execTable("POST", uri, headers, buf)
+
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusCreated}); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+// DeleteTable deletes the table given the specific
+// name. This function fails if the table is not present.
+// Be advised: DeleteTable deletes all the entries
+// that may be present.
+func (c *TableServiceClient) DeleteTable(table AzureTable) error {
+ uri := c.client.getEndpoint(tableServiceName, tablesURIPath, url.Values{})
+ uri += fmt.Sprintf("('%s')", string(table))
+
+ headers := c.getStandardHeaders()
+
+ headers["Content-Length"] = "0"
+
+ resp, err := c.client.execTable("DELETE", uri, headers, nil)
+
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusNoContent}); err != nil {
+ return err
+
+ }
+ return nil
+}
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/table_entities.go b/vendor/github.com/openshift/azure-sdk-for-go/storage/table_entities.go
new file mode 100644
index 00000000000..1b5919cd130
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/table_entities.go
@@ -0,0 +1,355 @@
+package storage
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "reflect"
+)
+
+const (
+ partitionKeyNode = "PartitionKey"
+ rowKeyNode = "RowKey"
+ tag = "table"
+ tagIgnore = "-"
+ continuationTokenPartitionKeyHeader = "X-Ms-Continuation-Nextpartitionkey"
+ continuationTokenRowHeader = "X-Ms-Continuation-Nextrowkey"
+ maxTopParameter = 1000
+)
+
+type queryTablesResponse struct {
+ TableName []struct {
+ TableName string `json:"TableName"`
+ } `json:"value"`
+}
+
+const (
+ tableOperationTypeInsert = iota
+ tableOperationTypeUpdate = iota
+ tableOperationTypeMerge = iota
+ tableOperationTypeInsertOrReplace = iota
+ tableOperationTypeInsertOrMerge = iota
+)
+
+type tableOperation int
+
+// TableEntity interface specifies
+// the functions needed to support
+// marshaling and unmarshaling into
+// Azure Tables. The struct must only contain
+// simple types because Azure Tables do not
+// support hierarchy.
+type TableEntity interface {
+ PartitionKey() string
+ RowKey() string
+ SetPartitionKey(string) error
+ SetRowKey(string) error
+}
+
+// ContinuationToken is an opaque (ie not useful to inspect)
+// struct that Get... methods can return if there are more
+// entries to be returned than the ones already
+// returned. Just pass it to the same function to continue
+// receiving the remaining entries.
+type ContinuationToken struct {
+ NextPartitionKey string
+ NextRowKey string
+}
+
+type getTableEntriesResponse struct {
+ Elements []map[string]interface{} `json:"value"`
+}
+
+// QueryTableEntities queries the specified table and returns the unmarshaled
+// entities of type retType.
+// top parameter limits the returned entries up to top. Maximum top
+// allowed by Azure API is 1000. In case there are more than top entries to be
+// returned the function will return a non nil *ContinuationToken. You can call the
+// same function again passing the received ContinuationToken as previousContToken
+// parameter in order to get the following entries. The query parameter
+// is the odata query. To retrieve all the entries pass the empty string.
+// The function returns a pointer to a TableEntity slice, the *ContinuationToken
+// if there are more entries to be returned and an error in case something went
+// wrong.
+//
+// Example:
+// entities, cToken, err = tSvc.QueryTableEntities("table", cToken, reflect.TypeOf(entity), 20, "")
+func (c *TableServiceClient) QueryTableEntities(tableName AzureTable, previousContToken *ContinuationToken, retType reflect.Type, top int, query string) ([]TableEntity, *ContinuationToken, error) {
+ if top > maxTopParameter {
+ return nil, nil, fmt.Errorf("top accepts at maximum %d elements. Requested %d instead", maxTopParameter, top)
+ }
+
+ uri := c.client.getEndpoint(tableServiceName, pathForTable(tableName), url.Values{})
+ uri += fmt.Sprintf("?$top=%d", top)
+ if query != "" {
+ uri += fmt.Sprintf("&$filter=%s", url.QueryEscape(query))
+ }
+
+ if previousContToken != nil {
+ uri += fmt.Sprintf("&NextPartitionKey=%s&NextRowKey=%s", previousContToken.NextPartitionKey, previousContToken.NextRowKey)
+ }
+
+ headers := c.getStandardHeaders()
+
+ headers["Content-Length"] = "0"
+
+ resp, err := c.client.execTable("GET", uri, headers, nil)
+
+ if err != nil {
+ return nil, nil, err
+ }
+
+ contToken := extractContinuationTokenFromHeaders(resp.headers)
+
+ if err != nil {
+ return nil, contToken, err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusOK}); err != nil {
+ return nil, contToken, err
+ }
+
+ retEntries, err := deserializeEntity(retType, resp.body)
+ if err != nil {
+ return nil, contToken, err
+ }
+
+ return retEntries, contToken, nil
+}
+
+// InsertEntity inserts an entity in the specified table.
+// The function fails if there is an entity with the same
+// PartitionKey and RowKey in the table.
+func (c *TableServiceClient) InsertEntity(table AzureTable, entity TableEntity) error {
+ var err error
+
+ if sc, err := c.execTable(table, entity, false, "POST"); err != nil {
+ return checkRespCode(sc, []int{http.StatusCreated})
+ }
+
+ return err
+}
+
+func (c *TableServiceClient) execTable(table AzureTable, entity TableEntity, specifyKeysInURL bool, method string) (int, error) {
+ uri := c.client.getEndpoint(tableServiceName, pathForTable(table), url.Values{})
+ if specifyKeysInURL {
+ uri += fmt.Sprintf("(PartitionKey='%s',RowKey='%s')", url.QueryEscape(entity.PartitionKey()), url.QueryEscape(entity.RowKey()))
+ }
+
+ headers := c.getStandardHeaders()
+
+ var buf bytes.Buffer
+
+ if err := injectPartitionAndRowKeys(entity, &buf); err != nil {
+ return 0, err
+ }
+
+ headers["Content-Length"] = fmt.Sprintf("%d", buf.Len())
+
+ var err error
+ var resp *odataResponse
+
+ resp, err = c.client.execTable(method, uri, headers, &buf)
+
+ if err != nil {
+ return 0, err
+ }
+
+ defer resp.body.Close()
+
+ return resp.statusCode, nil
+}
+
+// UpdateEntity updates the contents of an entity with the
+// one passed as parameter. The function fails if there is no entity
+// with the same PartitionKey and RowKey in the table.
+func (c *TableServiceClient) UpdateEntity(table AzureTable, entity TableEntity) error {
+ var err error
+
+ if sc, err := c.execTable(table, entity, true, "PUT"); err != nil {
+ return checkRespCode(sc, []int{http.StatusNoContent})
+ }
+ return err
+}
+
+// MergeEntity merges the contents of an entity with the
+// one passed as parameter.
+// The function fails if there is no entity
+// with the same PartitionKey and RowKey in the table.
+func (c *TableServiceClient) MergeEntity(table AzureTable, entity TableEntity) error {
+ var err error
+
+ if sc, err := c.execTable(table, entity, true, "MERGE"); err != nil {
+ return checkRespCode(sc, []int{http.StatusNoContent})
+ }
+ return err
+}
+
+// DeleteEntityWithoutCheck deletes the entity matching by
+// PartitionKey and RowKey. There is no check on IfMatch
+// parameter so the entity is always deleted.
+// The function fails if there is no entity
+// with the same PartitionKey and RowKey in the table.
+func (c *TableServiceClient) DeleteEntityWithoutCheck(table AzureTable, entity TableEntity) error {
+ return c.DeleteEntity(table, entity, "*")
+}
+
+// DeleteEntity deletes the entity matching by
+// PartitionKey, RowKey and ifMatch field.
+// The function fails if there is no entity
+// with the same PartitionKey and RowKey in the table or
+// the ifMatch is different.
+func (c *TableServiceClient) DeleteEntity(table AzureTable, entity TableEntity, ifMatch string) error {
+ uri := c.client.getEndpoint(tableServiceName, pathForTable(table), url.Values{})
+ uri += fmt.Sprintf("(PartitionKey='%s',RowKey='%s')", url.QueryEscape(entity.PartitionKey()), url.QueryEscape(entity.RowKey()))
+
+ headers := c.getStandardHeaders()
+
+ headers["Content-Length"] = "0"
+ headers["If-Match"] = ifMatch
+
+ resp, err := c.client.execTable("DELETE", uri, headers, nil)
+
+ if err != nil {
+ return err
+ }
+ defer resp.body.Close()
+
+ if err := checkRespCode(resp.statusCode, []int{http.StatusNoContent}); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+// InsertOrReplaceEntity inserts an entity in the specified table
+// or replaced the existing one.
+func (c *TableServiceClient) InsertOrReplaceEntity(table AzureTable, entity TableEntity) error {
+ var err error
+
+ if sc, err := c.execTable(table, entity, true, "PUT"); err != nil {
+ return checkRespCode(sc, []int{http.StatusNoContent})
+ }
+ return err
+}
+
+// InsertOrMergeEntity inserts an entity in the specified table
+// or merges the existing one.
+func (c *TableServiceClient) InsertOrMergeEntity(table AzureTable, entity TableEntity) error {
+ var err error
+
+ if sc, err := c.execTable(table, entity, true, "MERGE"); err != nil {
+ return checkRespCode(sc, []int{http.StatusNoContent})
+ }
+ return err
+}
+
+func injectPartitionAndRowKeys(entity TableEntity, buf *bytes.Buffer) error {
+ if err := json.NewEncoder(buf).Encode(entity); err != nil {
+ return err
+ }
+
+ dec := make(map[string]interface{})
+ if err := json.NewDecoder(buf).Decode(&dec); err != nil {
+ return err
+ }
+
+ // Inject PartitionKey and RowKey
+ dec[partitionKeyNode] = entity.PartitionKey()
+ dec[rowKeyNode] = entity.RowKey()
+
+ // Remove tagged fields
+ // The tag is defined in the const section
+ // This is useful to avoid storing the PartitionKey and RowKey twice.
+ numFields := reflect.ValueOf(entity).Elem().NumField()
+ for i := 0; i < numFields; i++ {
+ f := reflect.ValueOf(entity).Elem().Type().Field(i)
+
+ if f.Tag.Get(tag) == tagIgnore {
+ // we must look for its JSON name in the dictionary
+ // as the user can rename it using a tag
+ jsonName := f.Name
+ if f.Tag.Get("json") != "" {
+ jsonName = f.Tag.Get("json")
+ }
+ delete(dec, jsonName)
+ }
+ }
+
+ buf.Reset()
+
+ if err := json.NewEncoder(buf).Encode(&dec); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func deserializeEntity(retType reflect.Type, reader io.Reader) ([]TableEntity, error) {
+ buf := new(bytes.Buffer)
+
+ var ret getTableEntriesResponse
+ if err := json.NewDecoder(reader).Decode(&ret); err != nil {
+ return nil, err
+ }
+
+ tEntries := make([]TableEntity, len(ret.Elements))
+
+ for i, entry := range ret.Elements {
+
+ buf.Reset()
+ if err := json.NewEncoder(buf).Encode(entry); err != nil {
+ return nil, err
+ }
+
+ dec := make(map[string]interface{})
+ if err := json.NewDecoder(buf).Decode(&dec); err != nil {
+ return nil, err
+ }
+
+ var pKey, rKey string
+ // strip pk and rk
+ for key, val := range dec {
+ switch key {
+ case partitionKeyNode:
+ pKey = val.(string)
+ case rowKeyNode:
+ rKey = val.(string)
+ }
+ }
+
+ delete(dec, partitionKeyNode)
+ delete(dec, rowKeyNode)
+
+ buf.Reset()
+ if err := json.NewEncoder(buf).Encode(dec); err != nil {
+ return nil, err
+ }
+
+ // Create a empty retType instance
+ tEntries[i] = reflect.New(retType.Elem()).Interface().(TableEntity)
+ // Popolate it with the values
+ if err := json.NewDecoder(buf).Decode(&tEntries[i]); err != nil {
+ return nil, err
+ }
+
+ // Reset PartitionKey and RowKey
+ tEntries[i].SetPartitionKey(pKey)
+ tEntries[i].SetRowKey(rKey)
+ }
+
+ return tEntries, nil
+}
+
+func extractContinuationTokenFromHeaders(h http.Header) *ContinuationToken {
+ ct := ContinuationToken{h.Get(continuationTokenPartitionKeyHeader), h.Get(continuationTokenRowHeader)}
+
+ if ct.NextPartitionKey != "" && ct.NextRowKey != "" {
+ return &ct
+ }
+ return nil
+}
diff --git a/vendor/github.com/openshift/azure-sdk-for-go/storage/util.go b/vendor/github.com/openshift/azure-sdk-for-go/storage/util.go
new file mode 100644
index 00000000000..d71c6ce55d8
--- /dev/null
+++ b/vendor/github.com/openshift/azure-sdk-for-go/storage/util.go
@@ -0,0 +1,85 @@
+package storage
+
+import (
+ "bytes"
+ "crypto/hmac"
+ "crypto/sha256"
+ "encoding/base64"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "reflect"
+ "time"
+)
+
+func (c Client) computeHmac256(message string) string {
+ h := hmac.New(sha256.New, c.accountKey)
+ h.Write([]byte(message))
+ return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func currentTimeRfc1123Formatted() string {
+ return timeRfc1123Formatted(time.Now().UTC())
+}
+
+func timeRfc1123Formatted(t time.Time) string {
+ return t.Format(http.TimeFormat)
+}
+
+func mergeParams(v1, v2 url.Values) url.Values {
+ out := url.Values{}
+ for k, v := range v1 {
+ out[k] = v
+ }
+ for k, v := range v2 {
+ vals, ok := out[k]
+ if ok {
+ vals = append(vals, v...)
+ out[k] = vals
+ } else {
+ out[k] = v
+ }
+ }
+ return out
+}
+
+func prepareBlockListRequest(blocks []Block) string {
+ s := ``
+ for _, v := range blocks {
+ s += fmt.Sprintf("<%s>%s", v.Status, v.ID, v.Status)
+ }
+ s += ``
+ return s
+}
+
+func xmlUnmarshal(body io.Reader, v interface{}) error {
+ data, err := ioutil.ReadAll(body)
+ if err != nil {
+ return err
+ }
+ return xml.Unmarshal(data, v)
+}
+
+func xmlMarshal(v interface{}) (io.Reader, int, error) {
+ b, err := xml.Marshal(v)
+ if err != nil {
+ return nil, 0, err
+ }
+ return bytes.NewReader(b), len(b), nil
+}
+
+func headersFromStruct(v interface{}) map[string]string {
+ headers := make(map[string]string)
+ value := reflect.ValueOf(v)
+ for i := 0; i < value.NumField(); i++ {
+ key := value.Type().Field(i).Tag.Get("header")
+ val := value.Field(i).String()
+ if val != "" {
+ headers[key] = val
+ }
+ }
+ return headers
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index bbf97071263..408887223ba 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -24,6 +24,9 @@ github.com/AlecAivazis/survey/v2/terminal
## explicit
github.com/Azure/azure-sdk-for-go/profiles/2017-03-09/resources/mgmt/resources
github.com/Azure/azure-sdk-for-go/profiles/2018-03-01/dns/mgmt/dns
+github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/compute/mgmt/compute
+github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/network/mgmt/network
+github.com/Azure/azure-sdk-for-go/profiles/2019-03-01/storage/mgmt/storage
github.com/Azure/azure-sdk-for-go/profiles/latest/dns/mgmt/dns
github.com/Azure/azure-sdk-for-go/services/advisor/mgmt/2020-01-01/advisor
github.com/Azure/azure-sdk-for-go/services/analysisservices/mgmt/2017-08-01/analysisservices
@@ -36,6 +39,7 @@ github.com/Azure/azure-sdk-for-go/services/azurestackhci/mgmt/2020-10-01/azurest
github.com/Azure/azure-sdk-for-go/services/batch/mgmt/2020-03-01/batch
github.com/Azure/azure-sdk-for-go/services/cdn/mgmt/2019-04-15/cdn
github.com/Azure/azure-sdk-for-go/services/cognitiveservices/mgmt/2017-04-18/cognitiveservices
+github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2017-12-01/compute
github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-10-01/compute
github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2020-06-01/compute
github.com/Azure/azure-sdk-for-go/services/containerinstance/mgmt/2019-12-01/containerinstance
@@ -74,6 +78,7 @@ github.com/Azure/azure-sdk-for-go/services/mediaservices/mgmt/2020-05-01/media
github.com/Azure/azure-sdk-for-go/services/msi/mgmt/2018-11-30/msi
github.com/Azure/azure-sdk-for-go/services/mysql/mgmt/2020-01-01/mysql
github.com/Azure/azure-sdk-for-go/services/netapp/mgmt/2019-10-01/netapp
+github.com/Azure/azure-sdk-for-go/services/network/mgmt/2017-10-01/network
github.com/Azure/azure-sdk-for-go/services/network/mgmt/2018-12-01/network
github.com/Azure/azure-sdk-for-go/services/network/mgmt/2020-05-01/network
github.com/Azure/azure-sdk-for-go/services/network/mgmt/2020-07-01/network
@@ -130,6 +135,7 @@ github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2020-06-01/resources
github.com/Azure/azure-sdk-for-go/services/search/mgmt/2020-03-13/search
github.com/Azure/azure-sdk-for-go/services/servicebus/mgmt/2017-04-01/servicebus
github.com/Azure/azure-sdk-for-go/services/signalr/mgmt/2018-10-01/signalr
+github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage
github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2019-06-01/storage
github.com/Azure/azure-sdk-for-go/services/storagecache/mgmt/2020-03-01/storagecache
github.com/Azure/azure-sdk-for-go/services/storagesync/mgmt/2020-03-01/storagesync
@@ -137,6 +143,7 @@ github.com/Azure/azure-sdk-for-go/services/streamanalytics/mgmt/2016-03-01/strea
github.com/Azure/azure-sdk-for-go/services/timeseriesinsights/mgmt/2020-05-15/timeseriesinsights
github.com/Azure/azure-sdk-for-go/services/trafficmanager/mgmt/2018-04-01/trafficmanager
github.com/Azure/azure-sdk-for-go/services/web/mgmt/2020-06-01/web
+github.com/Azure/azure-sdk-for-go/storage
github.com/Azure/azure-sdk-for-go/version
# github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78
github.com/Azure/go-ansiterm
@@ -381,6 +388,23 @@ github.com/IBM/vpc-go-sdk/vpcclassicv1
github.com/IBM/vpc-go-sdk/vpcv1
# github.com/MakeNowJust/heredoc v1.0.0
github.com/MakeNowJust/heredoc
+# github.com/Microsoft/azure-vhd-utils v0.0.0-20181115010904-44cbada2ece3
+## explicit
+github.com/Microsoft/azure-vhd-utils/upload/concurrent
+github.com/Microsoft/azure-vhd-utils/upload/progress
+github.com/Microsoft/azure-vhd-utils/vhdcore
+github.com/Microsoft/azure-vhd-utils/vhdcore/bat
+github.com/Microsoft/azure-vhd-utils/vhdcore/block
+github.com/Microsoft/azure-vhd-utils/vhdcore/block/bitmap
+github.com/Microsoft/azure-vhd-utils/vhdcore/common
+github.com/Microsoft/azure-vhd-utils/vhdcore/diskstream
+github.com/Microsoft/azure-vhd-utils/vhdcore/footer
+github.com/Microsoft/azure-vhd-utils/vhdcore/header
+github.com/Microsoft/azure-vhd-utils/vhdcore/header/parentlocator
+github.com/Microsoft/azure-vhd-utils/vhdcore/reader
+github.com/Microsoft/azure-vhd-utils/vhdcore/validator
+github.com/Microsoft/azure-vhd-utils/vhdcore/vhdfile
+github.com/Microsoft/azure-vhd-utils/vhdcore/writer
# github.com/Netflix/go-expect v0.0.0-20190729225929-0e00d9168667
## explicit
# github.com/PuerkitoBio/purell v1.1.1
@@ -1387,6 +1411,9 @@ github.com/openshift/api/config/v1
github.com/openshift/api/operator/v1
github.com/openshift/api/operator/v1alpha1
github.com/openshift/api/route/v1
+# github.com/openshift/azure-sdk-for-go v4.0.0-beta.0.20160930180624-772f34e02704+incompatible
+## explicit
+github.com/openshift/azure-sdk-for-go/storage
# github.com/openshift/client-go v0.0.0-20210409155308-a8e62c60e930 => github.com/openshift/client-go v0.0.0-20200929181438-91d71ef2122c
## explicit
github.com/openshift/client-go/config/clientset/versioned