From 881259ee780f75380c6d262a5114b5effd52d243 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Wed, 5 Aug 2020 16:52:45 +0800 Subject: [PATCH 01/23] update --- azurerm/internal/clients/client.go | 3 + .../avs/avs_private_clouds_data_source.go | 61 + .../avs/avs_private_clouds_resource.go | 630 ++++++ .../internal/services/avs/client/client.go | 33 + .../services/avs/parse/avs_authorizations.go | 32 + .../avs/parse/avs_authorizations_test.go | 77 + .../services/avs/parse/avs_clusters.go | 33 + .../services/avs/parse/avs_clusters_test.go | 77 + .../avs/parse/avs_hcx_enterprise_sites.go | 33 + .../parse/avs_hcx_enterprise_sites_test.go | 77 + .../services/avs/parse/avs_private_clouds.go | 29 + .../avs/parse/avs_private_clouds_test.go | 72 + azurerm/internal/services/avs/registration.go | 37 + .../avs_private_clouds_data_source_test.go | 36 + .../tests/avs_private_clouds_resource_test.go | 363 ++++ .../docs/d/avs_authorizations.html.markdown | 47 + .../website/docs/d/avs_clusters.html.markdown | 47 + .../d/avs_hcx_enterprise_sites.html.markdown | 47 + .../docs/d/avs_private_clouds.html.markdown | 48 + .../docs/r/avs_authorizations.html.markdown | 78 + .../website/docs/r/avs_clusters.html.markdown | 93 + .../r/avs_hcx_enterprise_sites.html.markdown | 76 + .../docs/r/avs_private_clouds.html.markdown | 159 ++ .../avs/mgmt/2020-03-20/avs/authorizations.go | 432 ++++ .../mgmt/2020-03-20/avs/avsapi/interfaces.go | 89 + .../avs/mgmt/2020-03-20/avs/client.go | 52 + .../avs/mgmt/2020-03-20/avs/clusters.go | 526 +++++ .../mgmt/2020-03-20/avs/hcxenterprisesites.go | 433 ++++ .../avs/mgmt/2020-03-20/avs/locations.go | 201 ++ .../avs/mgmt/2020-03-20/avs/models.go | 1770 +++++++++++++++++ .../avs/mgmt/2020-03-20/avs/operations.go | 149 ++ .../avs/mgmt/2020-03-20/avs/privateclouds.go | 719 +++++++ .../avs/mgmt/2020-03-20/avs/version.go | 30 + 33 files changed, 6589 insertions(+) create mode 100644 azurerm/internal/services/avs/avs_private_clouds_data_source.go create mode 100644 azurerm/internal/services/avs/avs_private_clouds_resource.go create mode 100644 azurerm/internal/services/avs/client/client.go create mode 100644 azurerm/internal/services/avs/parse/avs_authorizations.go create mode 100644 azurerm/internal/services/avs/parse/avs_authorizations_test.go create mode 100644 azurerm/internal/services/avs/parse/avs_clusters.go create mode 100644 azurerm/internal/services/avs/parse/avs_clusters_test.go create mode 100644 azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go create mode 100644 azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go create mode 100644 azurerm/internal/services/avs/parse/avs_private_clouds.go create mode 100644 azurerm/internal/services/avs/parse/avs_private_clouds_test.go create mode 100644 azurerm/internal/services/avs/registration.go create mode 100644 azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go create mode 100644 azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go create mode 100644 azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown create mode 100644 azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown create mode 100644 azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown create mode 100644 azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown create mode 100644 azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown create mode 100644 azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown create mode 100644 azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown create mode 100644 azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/clusters.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/models.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/privateclouds.go create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/version.go diff --git a/azurerm/internal/clients/client.go b/azurerm/internal/clients/client.go index 97e9f9678029..714449ba8780 100644 --- a/azurerm/internal/clients/client.go +++ b/azurerm/internal/clients/client.go @@ -14,6 +14,7 @@ import ( appPlatform "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/appplatform/client" authorization "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/authorization/client" automation "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/automation/client" + avs "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/client" batch "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/batch/client" blueprints "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/blueprints/client" bot "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/bot/client" @@ -99,6 +100,7 @@ type Client struct { AppPlatform *appPlatform.Client Authorization *authorization.Client Automation *automation.Client + Avs *avs.Client Batch *batch.Client Blueprints *blueprints.Client Bot *bot.Client @@ -185,6 +187,7 @@ func (client *Client) Build(ctx context.Context, o *common.ClientOptions) error client.AppPlatform = appPlatform.NewClient(o) client.Authorization = authorization.NewClient(o) client.Automation = automation.NewClient(o) + client.Avs = avs.NewClient(o) client.Batch = batch.NewClient(o) client.Blueprints = blueprints.NewClient(o) client.Bot = bot.NewClient(o) diff --git a/azurerm/internal/services/avs/avs_private_clouds_data_source.go b/azurerm/internal/services/avs/avs_private_clouds_data_source.go new file mode 100644 index 000000000000..f17087e87cf8 --- /dev/null +++ b/azurerm/internal/services/avs/avs_private_clouds_data_source.go @@ -0,0 +1,61 @@ +package avs + +import ( + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "time" +) +func dataSourceAvsPrivateCloud() *schema.Resource { + return &schema.Resource{ + Read: dataSourceArmAvsPrivateCloudRead, + + Timeouts: &schema.ResourceTimeout{ + Read: schema.DefaultTimeout(5 * time.Minute), + }, + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + }, + + "resource_group_name": azure.SchemaResourceGroupNameForDataSource(), + + "location": azure.SchemaLocationForDataSource(), + + "tags": tags.SchemaDataSource(), + }, + } +} + +func dataSourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) + defer cancel() + + name := d.Get("name").(string) + resourceGroup := d.Get("resource_group_name").(string) + + resp, err :=client.Get(ctx, resourceGroup, name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("Avs PrivateCloud %q does not exist", name) + } + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + if resp.ID == nil || *resp.ID== "" { + return fmt.Errorf("empty or nil ID returned for Avs PrivateCloud %q (Resource Group %q) ID", name, resourceGroup) + } + + d.SetId(*resp.ID) + d.Set("name", name) + d.Set("resource_group_name", resourceGroup) + d.Set("location", location.NormalizeNilable(resp.Location)) + return tags.FlattenAndSet(d, resp.Tags) +} diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go new file mode 100644 index 000000000000..a8fa54c1bf00 --- /dev/null +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -0,0 +1,630 @@ +package avs + +import ( + "fmt" + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags" + azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "log" + "time" +) +func resourceArmAvsPrivateCloud() *schema.Resource { + return &schema.Resource{ + Create: resourceArmAvsPrivateCloudCreate, + Read: resourceArmAvsPrivateCloudRead, + Update: resourceArmAvsPrivateCloudUpdate, + Delete: resourceArmAvsPrivateCloudDelete, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(30 * time.Minute), + Read: schema.DefaultTimeout(5 * time.Minute), + Update: schema.DefaultTimeout(30 * time.Minute), + Delete: schema.DefaultTimeout(30 * time.Minute), + }, + + Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { + _, err := parse.AvsPrivateCloudID(id) + return err + }), + + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "resource_group_name": azure.SchemaResourceGroupName(), + + "location": azure.SchemaLocation(), + + "sku": { + Type: schema.TypeList, + Required: true, + ForceNew: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + }, + }, + }, + + "management_cluster": { + Type: schema.TypeList, + Required: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "cluster_size": { + Type: schema.TypeInt, + Required: true, + }, + + "cluster_id": { + Type: schema.TypeInt, + Computed: true, + }, + + "hosts": { + Type: schema.TypeSet, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + }, + }, + + "network_block": { + Type: schema.TypeString, + Required: true, + }, + + "circuit": { + Type: schema.TypeList, + Computed: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "express_route_id": { + Type: schema.TypeString, + Computed: true, + }, + + "express_route_private_peering_id": { + Type: schema.TypeString, + Computed: true, + }, + + "primary_subnet": { + Type: schema.TypeString, + Computed: true, + }, + + "secondary_subnet": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + + "identity_source": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Optional: true, + }, + + "alias": { + Type: schema.TypeString, + Optional: true, + }, + + "base_group_dn": { + Type: schema.TypeString, + Optional: true, + }, + + "base_user_dn": { + Type: schema.TypeString, + Optional: true, + }, + + "domain": { + Type: schema.TypeString, + Optional: true, + }, + + "password": { + Type: schema.TypeString, + Optional: true, + }, + + "primary_server": { + Type: schema.TypeString, + Optional: true, + }, + + "secondary_server": { + Type: schema.TypeString, + Optional: true, + }, + + "ssl": { + Type: schema.TypeBool, + Optional: true, + }, + + "username": { + Type: schema.TypeString, + Optional: true, + }, + }, + }, + }, + + "internet": { + Type: schema.TypeBool, + Optional: true, + }, + + "nsxt_password": { + Type: schema.TypeString, + Optional: true, + }, + + "vcenter_password": { + Type: schema.TypeString, + Optional: true, + }, + + "endpoint": { + Type: schema.TypeList, + Computed: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "hcx_cloud_manager": { + Type: schema.TypeString, + Computed: true, + }, + + "nsxt_manager": { + Type: schema.TypeString, + Computed: true, + }, + + "vcsa": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + + "management_network": { + Type: schema.TypeString, + Computed: true, + }, + + "nsxt_certificate_thumbprint": { + Type: schema.TypeString, + Computed: true, + }, + + "provisioning_network": { + Type: schema.TypeString, + Computed: true, + }, + + "type": { + Type: schema.TypeString, + Computed: true, + }, + + "vcenter_certificate_thumbprint": { + Type: schema.TypeString, + Computed: true, + }, + + "vmotion_network": { + Type: schema.TypeString, + Computed: true, + }, + + "tags": tags.Schema(), + }, + } +} +func resourceArmAvsPrivateCloudCreate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) + defer cancel() + + name := d.Get("name").(string) + resourceGroup := d.Get("resource_group_name").(string) + + existing, err :=client.Get(ctx, resourceGroup, name) + if err != nil { + if !utils.ResponseWasNotFound(existing.Response) { + return fmt.Errorf("checking for present of existing Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + } + if existing.ID != nil && *existing.ID != "" { + return tf.ImportAsExistsError("azurerm_avs_private_cloud", *existing.ID) + } + + internet := avs.Disabled + if d.Get("internet").(bool) { + internet = avs.Enabled + } + + privateCloud := avs.PrivateCloud{ + Location: utils.String(location.Normalize(d.Get("location").(string))), + Sku: expandArmPrivateCloudSku(d.Get("sku").([]interface{})), + PrivateCloudProperties: &avs.PrivateCloudProperties{ + ManagementCluster: expandArmPrivateCloudManagementCluster(d.Get("management_cluster").([]interface{})), + NetworkBlock: utils.String(d.Get("network_block").(string)), + IdentitySources: expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()), + Internet: internet, + NsxtPassword: utils.String(d.Get("nsxt_password").(string)), + VcenterPassword: utils.String(d.Get("vcenter_password").(string)), + }, + Tags: tags.Expand(d.Get("tags").(map[string]interface{})), + } + future, err :=client.CreateOrUpdate(ctx, resourceGroup, name, privateCloud) + if err != nil { + return fmt.Errorf("creating Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on creating future for Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + + resp, err :=client.Get(ctx, resourceGroup, name) + if err != nil { + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + + if resp.ID == nil || *resp.ID== "" { + return fmt.Errorf("empty or nil ID returned for Avs PrivateCloud %q (Resource Group %q) ID", name, resourceGroup) + } + + d.SetId(*resp.ID) + return resourceArmAvsPrivateCloudRead(d, meta) +} + +func resourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsPrivateCloudID(d.Id()) + if err != nil { + return err + } + + resp, err :=client.Get(ctx, id.ResourceGroup, id.Name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + log.Printf("[INFO] avs %q does not exist - removing from state", d.Id()) + d.SetId("") + return nil + } + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + d.Set("name", id.Name) + d.Set("resource_group_name", id.ResourceGroup) + d.Set("location", location.NormalizeNilable(resp.Location)) + if props := resp.PrivateCloudProperties; props != nil { + if err := d.Set("management_cluster", flattenArmPrivateCloudManagementCluster(props.ManagementCluster)); err != nil { + return fmt.Errorf("setting `management_cluster`: %+v", err) + } + d.Set("network_block", props.NetworkBlock) + if err := d.Set("circuit", flattenArmPrivateCloudCircuit(props.Circuit)); err != nil { + return fmt.Errorf("setting `circuit`: %+v", err) + } + if err := d.Set("identity_source", flattenArmPrivateCloudIdentitySourceArray(props.IdentitySources)); err != nil { + return fmt.Errorf("setting `identity_source`: %+v", err) + } + d.Set("internet", props.Internet==avs.Enabled) + d.Set("nsxt_password", props.NsxtPassword) + d.Set("vcenter_password", props.VcenterPassword) + if err := d.Set("endpoint", flattenArmPrivateCloudEndpoints(props.Endpoints)); err != nil { + return fmt.Errorf("setting `endpoint`: %+v", err) + } + d.Set("management_network", props.ManagementNetwork) + d.Set("nsxt_certificate_thumbprint", props.NsxtCertificateThumbprint) + d.Set("provisioning_network", props.ProvisioningNetwork) + d.Set("vcenter_certificate_thumbprint", props.VcenterCertificateThumbprint) + d.Set("vmotion_network", props.VmotionNetwork) + } + if err := d.Set("sku", flattenArmPrivateCloudSku(resp.Sku)); err != nil { + return fmt.Errorf("setting `sku`: %+v", err) + } + d.Set("type", resp.Type) + return tags.FlattenAndSet(d, resp.Tags) +} + +func resourceArmAvsPrivateCloudUpdate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsPrivateCloudID(d.Id()) + if err != nil { + return err + } + + privateCloudUpdate := avs.PrivateCloudUpdate{ + PrivateCloudUpdateProperties: &avs.PrivateCloudUpdateProperties{ + }, + } + if d.HasChange("management_cluster") { + privateCloudUpdate.PrivateCloudUpdateProperties.ManagementCluster = expandArmPrivateCloudManagementCluster(d.Get("management_cluster").([]interface{})) + } + if d.HasChange("internet") { + internet := avs.Disabled + if d.Get("internet").(bool) { + internet = avs.Enabled + } + privateCloudUpdate.PrivateCloudUpdateProperties.Internet = internet + } + if d.HasChange("identity_source") { + privateCloudUpdate.PrivateCloudUpdateProperties.IdentitySources = expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()) + } + if d.HasChange("tags") { + privateCloudUpdate.Tags = tags.Expand(d.Get("tags").(map[string]interface{})) + } + + future, err :=client.Update(ctx, id.ResourceGroup, id.Name, privateCloudUpdate) + if err != nil { + return fmt.Errorf("updating Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on updating future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + return resourceArmAvsPrivateCloudRead(d, meta) +} + +func resourceArmAvsPrivateCloudDelete(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsPrivateCloudID(d.Id()) + if err != nil { + return err + } + + future, err :=client.Delete(ctx, id.ResourceGroup, id.Name) + if err != nil { + return fmt.Errorf("deleting Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on deleting future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + return nil +} + +func expandArmPrivateCloudSku(input []interface{}) *avs.Sku { + if len(input) == 0 { + return nil + } + v := input[0].(map[string]interface{}) + return &avs.Sku{ + Name: utils.String(v["name"].(string)), + } +} + +func expandArmPrivateCloudManagementCluster(input []interface{}) *avs.ManagementCluster { + if len(input) == 0 { + return nil + } + v := input[0].(map[string]interface{}) + return &avs.ManagementCluster{ + ClusterSize: utils.Int32(int32(v["cluster_size"].(int))), + } +} + +func expandArmPrivateCloudIdentitySourceArray(input []interface{}) *[]avs.IdentitySource { + results := make([]avs.IdentitySource, 0) + for _, item := range input { + v := item.(map[string]interface{}) + sSL := avs.SslEnumDisabled + if v["ssl"].(bool) { + sSL = avs.SslEnumEnabled + } + result := avs.IdentitySource{ + Name: utils.String(v["name"].(string)), + Alias: utils.String(v["alias"].(string)), + Domain: utils.String(v["domain"].(string)), + BaseUserDN: utils.String(v["base_user_dn"].(string)), + BaseGroupDN: utils.String(v["base_group_dn"].(string)), + PrimaryServer: utils.String(v["primary_server"].(string)), + SecondaryServer: utils.String(v["secondary_server"].(string)), + Ssl: sSL, + Username: utils.String(v["username"].(string)), + Password: utils.String(v["password"].(string)), + } + results = append(results, result) + } + return &results +} + +func flattenArmPrivateCloudManagementCluster(input *avs.ManagementCluster) []interface{} { + if input == nil { + return make([]interface{}, 0) + } + + var clusterSize int32 + if input.ClusterSize != nil { + clusterSize = *input.ClusterSize + } + var clusterId int32 + if input.ClusterID != nil { + clusterId = *input.ClusterID + } + return []interface{}{ + map[string]interface{}{ + "cluster_size": clusterSize, + "cluster_id": clusterId, + "hosts": utils.FlattenStringSlice(input.Hosts), + }, + } +} + +func flattenArmPrivateCloudCircuit(input *avs.Circuit) []interface{} { + if input == nil { + return make([]interface{}, 0) + } + + var expressRouteId string + if input.ExpressRouteID != nil { + expressRouteId = *input.ExpressRouteID + } + var expressRoutePrivatePeeringId string + if input.ExpressRoutePrivatePeeringID != nil { + expressRoutePrivatePeeringId = *input.ExpressRoutePrivatePeeringID + } + var primarySubnet string + if input.PrimarySubnet != nil { + primarySubnet = *input.PrimarySubnet + } + var secondarySubnet string + if input.SecondarySubnet != nil { + secondarySubnet = *input.SecondarySubnet + } + return []interface{}{ + map[string]interface{}{ + "express_route_id": expressRouteId, + "express_route_private_peering_id": expressRoutePrivatePeeringId, + "primary_subnet": primarySubnet, + "secondary_subnet": secondarySubnet, + }, + } +} + +func flattenArmPrivateCloudIdentitySourceArray(input *[]avs.IdentitySource) []interface{} { + results := make([]interface{}, 0) + if input == nil { + return results + } + + for _, item := range *input { + var name string + if item.Name != nil { + name = *item.Name + } + var alias string + if item.Alias != nil { + alias = *item.Alias + } + var baseGroupDn string + if item.BaseGroupDN != nil { + baseGroupDn = *item.BaseGroupDN + } + var baseUserDn string + if item.BaseUserDN != nil { + baseUserDn = *item.BaseUserDN + } + var domain string + if item.Domain != nil { + domain = *item.Domain + } + var password string + if item.Password != nil { + password = *item.Password + } + var primaryServer string + if item.PrimaryServer != nil { + primaryServer = *item.PrimaryServer + } + var secondaryServer string + if item.SecondaryServer != nil { + secondaryServer = *item.SecondaryServer + } + sSL := item.Ssl==avs.SslEnumEnabled + var username string + if item.Username != nil { + username = *item.Username + } + v := map[string]interface{}{ + "name": name, + "alias": alias, + "base_group_dn": baseGroupDn, + "base_user_dn": baseUserDn, + "domain": domain, + "password": password, + "primary_server": primaryServer, + "secondary_server": secondaryServer, + "ssl": sSL, + "username": username, + } + results = append(results, v) + } + return results +} + +func flattenArmPrivateCloudEndpoints(input *avs.Endpoints) []interface{} { + if input == nil { + return make([]interface{}, 0) + } + + var hcxCloudManager string + if input.HcxCloudManager != nil { + hcxCloudManager = *input.HcxCloudManager + } + var nsxtManager string + if input.NsxtManager != nil { + nsxtManager = *input.NsxtManager + } + var vcsa string + if input.Vcsa != nil { + vcsa = *input.Vcsa + } + return []interface{}{ + map[string]interface{}{ + "hcx_cloud_manager": hcxCloudManager, + "nsxt_manager": nsxtManager, + "vcsa": vcsa, + }, + } +} + +func flattenArmPrivateCloudSku(input *avs.Sku) []interface{} { + if input == nil { + return make([]interface{}, 0) + } + + var name string + if input.Name != nil { + name = *input.Name + } + return []interface{}{ + map[string]interface{}{ + "name": name, + }, + } +} diff --git a/azurerm/internal/services/avs/client/client.go b/azurerm/internal/services/avs/client/client.go new file mode 100644 index 000000000000..dff68a01c8c5 --- /dev/null +++ b/azurerm/internal/services/avs/client/client.go @@ -0,0 +1,33 @@ +package client + +import ( + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/common" +) +type Client struct { + PrivateCloudClient *avs.PrivateCloudsClient + ClusterClient *avs.ClustersClient + HcxEnterpriseSiteClient *avs.HcxEnterpriseSitesClient + AuthorizationClient *avs.AuthorizationsClient +} + +func NewClient(o *common.ClientOptions) *Client { + privateCloudClient := avs.NewPrivateCloudsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&privateCloudClient.Client, o.ResourceManagerAuthorizer) + + clusterClient := avs.NewClustersClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&clusterClient.Client, o.ResourceManagerAuthorizer) + + hcxEnterpriseSiteClient := avs.NewHcxEnterpriseSitesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&hcxEnterpriseSiteClient.Client, o.ResourceManagerAuthorizer) + + authorizationClient := avs.NewAuthorizationsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&authorizationClient.Client, o.ResourceManagerAuthorizer) + + return &Client{ + PrivateCloudClient: &privateCloudClient, + ClusterClient: &clusterClient, + HcxEnterpriseSiteClient: &hcxEnterpriseSiteClient, + AuthorizationClient: &authorizationClient, + } +} diff --git a/azurerm/internal/services/avs/parse/avs_authorizations.go b/azurerm/internal/services/avs/parse/avs_authorizations.go new file mode 100644 index 000000000000..2a731776e466 --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_authorizations.go @@ -0,0 +1,32 @@ +package parse +import ( + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) +type AvsAuthorizationId struct { + ResourceGroup string + PrivateCloudName string + Name string +} + +func AvsAuthorizationID(input string) (*AvsAuthorizationId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsAuthorization ID %q: %+v", input, err) + } + + avsAuthorization := AvsAuthorizationId{ + ResourceGroup: id.ResourceGroup, + } + if avsAuthorization.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if avsAuthorization.Name, err = id.PopSegment("authorizations"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &avsAuthorization, nil +} diff --git a/azurerm/internal/services/avs/parse/avs_authorizations_test.go b/azurerm/internal/services/avs/parse/avs_authorizations_test.go new file mode 100644 index 000000000000..92aa90a0119c --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_authorizations_test.go @@ -0,0 +1,77 @@ +package parse + +import ( + "testing" +) + +func TestAvsAuthorizationID(t *testing.T) { + testData := []struct { + Name string + Input string + Expected *AvsAuthorizationId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing Authorization Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations", + Expected: nil, + }, + { + Name: "avs Authorization ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1", + Expected: &AvsAuthorizationId{ + ResourceGroup:"resourceGroup1", + PrivateCloudName:"privateCloud1", + Name:"authorization1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/Authorizations/authorization1", + Expected: nil, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) + + actual, err := AvsAuthorizationID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } + + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + + if actual.PrivateCloudName != v.Expected.PrivateCloudName { + t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) + } + + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/avs/parse/avs_clusters.go b/azurerm/internal/services/avs/parse/avs_clusters.go new file mode 100644 index 000000000000..baa1b08c9e4d --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_clusters.go @@ -0,0 +1,33 @@ +package parse + +import ( + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) +type AvsClusterId struct { + ResourceGroup string + PrivateCloudName string + Name string +} + +func AvsClusterID(input string) (*AvsClusterId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsCluster ID %q: %+v", input, err) + } + + avsCluster := AvsClusterId{ + ResourceGroup: id.ResourceGroup, + } + if avsCluster.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if avsCluster.Name, err = id.PopSegment("clusters"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &avsCluster, nil +} diff --git a/azurerm/internal/services/avs/parse/avs_clusters_test.go b/azurerm/internal/services/avs/parse/avs_clusters_test.go new file mode 100644 index 000000000000..15ad350cdf91 --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_clusters_test.go @@ -0,0 +1,77 @@ +package parse + +import ( + "testing" +) + +func TestAvsClusterID(t *testing.T) { + testData := []struct { + Name string + Input string + Expected *AvsClusterId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing Cluster Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters", + Expected: nil, + }, + { + Name: "avs Cluster ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters/cluster1", + Expected: &AvsClusterId{ + ResourceGroup:"resourceGroup1", + PrivateCloudName:"privateCloud1", + Name:"cluster1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/Clusters/cluster1", + Expected: nil, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) + + actual, err := AvsClusterID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } + + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + + if actual.PrivateCloudName != v.Expected.PrivateCloudName { + t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) + } + + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go b/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go new file mode 100644 index 000000000000..a6dbc043d15a --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go @@ -0,0 +1,33 @@ +package parse + +import ( + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) +type AvsHcxEnterpriseSiteId struct { + ResourceGroup string + PrivateCloudName string + Name string +} + +func AvsHcxEnterpriseSiteID(input string) (*AvsHcxEnterpriseSiteId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsHcxEnterpriseSite ID %q: %+v", input, err) + } + + avsHcxEnterpriseSite := AvsHcxEnterpriseSiteId{ + ResourceGroup: id.ResourceGroup, + } + if avsHcxEnterpriseSite.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if avsHcxEnterpriseSite.Name, err = id.PopSegment("hcxEnterpriseSites"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &avsHcxEnterpriseSite, nil +} diff --git a/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go b/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go new file mode 100644 index 000000000000..446154273fe2 --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go @@ -0,0 +1,77 @@ +package parse + +import ( + "testing" +) + +func TestAvsHcxEnterpriseSiteID(t *testing.T) { + testData := []struct { + Name string + Input string + Expected *AvsHcxEnterpriseSiteId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing HcxEnterpriseSite Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/hcxEnterpriseSites", + Expected: nil, + }, + { + Name: "avs HcxEnterpriseSite ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/hcxEnterpriseSites/hcxEnterpriseSite1", + Expected: &AvsHcxEnterpriseSiteId{ + ResourceGroup:"resourceGroup1", + PrivateCloudName:"privateCloud1", + Name:"hcxEnterpriseSite1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/HcxEnterpriseSites/hcxEnterpriseSite1", + Expected: nil, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) + + actual, err := AvsHcxEnterpriseSiteID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } + + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + + if actual.PrivateCloudName != v.Expected.PrivateCloudName { + t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) + } + + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/avs/parse/avs_private_clouds.go b/azurerm/internal/services/avs/parse/avs_private_clouds.go new file mode 100644 index 000000000000..631f7e3367fb --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_private_clouds.go @@ -0,0 +1,29 @@ +package parse + +import ( + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) +type AvsPrivateCloudId struct { + ResourceGroup string + Name string +} + +func AvsPrivateCloudID(input string) (*AvsPrivateCloudId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsPrivateCloud ID %q: %+v", input, err) + } + + avsPrivateCloud := AvsPrivateCloudId{ + ResourceGroup: id.ResourceGroup, + } + if avsPrivateCloud.Name, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &avsPrivateCloud, nil +} diff --git a/azurerm/internal/services/avs/parse/avs_private_clouds_test.go b/azurerm/internal/services/avs/parse/avs_private_clouds_test.go new file mode 100644 index 000000000000..aae5c201712b --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_private_clouds_test.go @@ -0,0 +1,72 @@ +package parse + +import ( + "testing" +) + +func TestAvsPrivateCloudID(t *testing.T) { + testData := []struct { + Name string + Input string + Expected *AvsPrivateCloudId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing PrivateCloud Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds", + Expected: nil, + }, + { + Name: "avs PrivateCloud ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1", + Expected: &AvsPrivateCloudId{ + ResourceGroup:"resourceGroup1", + Name:"privateCloud1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/PrivateClouds/privateCloud1", + Expected: nil, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) + + actual, err := AvsPrivateCloudID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } + + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/avs/registration.go b/azurerm/internal/services/avs/registration.go new file mode 100644 index 000000000000..265fd5bdcb7a --- /dev/null +++ b/azurerm/internal/services/avs/registration.go @@ -0,0 +1,37 @@ +package avs + +import "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + +type Registration struct{} + +// Name is the name of this Service +func (r Registration) Name() string { + return "Avs" +} + +// WebsiteCategories returns a list of categories which can be used for the sidebar +func (r Registration) WebsiteCategories() []string { + return []string{ + "Avs", + } +} + +// SupportedDataSources returns the supported Data Sources supported by this Service +func (r Registration) SupportedDataSources() map[string]*schema.Resource { + return map[string]*schema.Resource{ + "azurerm_avs_private_cloud": dataSourceAvsPrivateCloud(), + "azurerm_avs_cluster": dataSourceAvsCluster(), + "azurerm_avs_hcx_enterprise_site": dataSourceAvsHcxEnterpriseSite(), + "azurerm_avs_authorization": dataSourceAvsAuthorization(), + } +} + +// SupportedResources returns the supported Resources supported by this Service +func (r Registration) SupportedResources() map[string]*schema.Resource { + return map[string]*schema.Resource{ + "azurerm_avs_private_cloud": resourceArmAvsPrivateCloud(), + "azurerm_avs_cluster": resourceArmAvsCluster(), + "azurerm_avs_hcx_enterprise_site": resourceArmAvsHcxEnterpriseSite(), + "azurerm_avs_authorization": resourceArmAvsAuthorization(), + } +} diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go new file mode 100644 index 000000000000..d84a4baa121a --- /dev/null +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go @@ -0,0 +1,36 @@ +package tests + +import ( + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" + "testing" +) +func TestAccDataSourceAzureRMavsPrivateCloud_basic(t *testing.T) { + data := acceptance.BuildTestData(t, "data.azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccDataSourceavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + }, + }) +} + +func testAccDataSourceavsPrivateCloud_basic(data acceptance.TestData) string { + config := testAccAzureRMavsPrivateCloud_basic(data) + return fmt.Sprintf(` +%s + +data "azurerm_avs_private_cloud" "test" { + name = azurerm_avs_private_cloud.test.name + resource_group_name = azurerm_avs_private_cloud.test.resource_group_name +} +`, config) +} diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go new file mode 100644 index 000000000000..7450e4db545f --- /dev/null +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -0,0 +1,363 @@ +package tests + +import ( + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "testing" +) + +func TestAccAzureRMavsPrivateCloud_basic(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func TestAccAzureRMavsPrivateCloud_requiresImport(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.RequiresImportErrorStep(testAccAzureRMavsPrivateCloud_requiresImport), + }, + }) +} + +func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_complete(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_complete(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func TestAccAzureRMavsPrivateCloud_updateManagementCluster(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_complete(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_updateManagementCluster(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_complete(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_updateIdentitySources(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func testCheckAzureRMavsPrivateCloudExists(resourceName string) resource.TestCheckFunc { + return func(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.PrivateCloudClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("avs PrivateCloud not found: %s", resourceName) + } + id, err := parse.AvsPrivateCloudID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Avs PrivateCloud %q does not exist", id.Name) + } + return fmt.Errorf("bad: Get on Avs.PrivateCloudClient: %+v", err) + } + return nil + } +} + +func testCheckAzureRMavsPrivateCloudDestroy(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.PrivateCloudClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + + for _, rs := range s.RootModule().Resources { + if rs.Type != "azurerm_avs_private_cloud" { + continue + } + id, err := parse.AvsPrivateCloudID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Get on Avs.PrivateCloudClient: %+v", err) + } + } + return nil + } + return nil +} + +func testAccAzureRMavsPrivateCloud_template(data acceptance.TestData) string { + return fmt.Sprintf(` +provider "azurerm" { + features {} +} + +resource "azurerm_resource_group" "test" { + name = "acctest-avs-%d" + location = "%s" +} +`, data.RandomInteger, data.Locations.Primary) +} + +func testAccAzureRMavsPrivateCloud_basic(data acceptance.TestData) string { + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + sku { + name = "av36" + } + + management_cluster { + cluster_size = 4 + } + network_block = "192.168.48.0/22" +} +`, template, data.RandomInteger) +} + +func testAccAzureRMavsPrivateCloud_requiresImport(data acceptance.TestData) string { + config := testAccAzureRMavsPrivateCloud_basic(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_private_cloud" "import" { + name = azurerm_avs_private_cloud.test.name + resource_group_name = azurerm_avs_private_cloud.test.resource_group_name + location = azurerm_avs_private_cloud.test.location + sku { + name = azurerm_avs_private_cloud.test.sku.name + } + management_cluster { + cluster_size = azurerm_avs_private_cloud.test.management_cluster.cluster_size + } + network_block = azurerm_avs_private_cloud.test.network_block +} +`, config) +} + +func testAccAzureRMavsPrivateCloud_complete(data acceptance.TestData) string { + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + sku { + name = "AV36" + } + + management_cluster { + cluster_size = 4 + } + network_block = "192.168.48.0/22" + identity_source { + name = "" + alias = "" + base_group_dn = "" + base_user_dn = "" + domain = "" + password = "" + primary_server = "" + secondary_server = "" + ssl = false + username = "" + } + internet = false + nsxt_password = "" + vcenter_password = "" + tags = { + ENV = "Test" + } +} +`, template, data.RandomInteger) +} + +func testAccAzureRMavsPrivateCloud_updateManagementCluster(data acceptance.TestData) string { + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + sku { + name = "AV36" + } + + management_cluster { + cluster_size = 4 + } + network_block = "192.168.48.0/22" + identity_source { + name = "" + alias = "" + base_group_dn = "" + base_user_dn = "" + domain = "" + password = "" + primary_server = "" + secondary_server = "" + ssl = false + username = "" + } + internet = false + nsxt_password = "" + vcenter_password = "" + tags = { + ENV = "Test" + } +} +`, template, data.RandomInteger) +} + +func testAccAzureRMavsPrivateCloud_updateIdentitySources(data acceptance.TestData) string { + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + sku { + name = "AV36" + } + + management_cluster { + cluster_size = 4 + } + network_block = "192.168.48.0/22" + identity_source { + name = "" + alias = "" + base_group_dn = "" + base_user_dn = "" + domain = "" + password = "" + primary_server = "" + secondary_server = "" + ssl = false + username = "" + } + internet = false + nsxt_password = "" + vcenter_password = "" + tags = { + ENV = "Test" + } +} +`, template, data.RandomInteger) +} diff --git a/azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown new file mode 100644 index 000000000000..6f2c6e9881d6 --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown @@ -0,0 +1,47 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: Data Source: azurerm_avs_authorization" +description: |- + Gets information about an existing avs Authorization. +--- + +# Data Source: azurerm_avs_authorization + +Use this data source to access information about an existing avs Authorization. + +## Example Usage + +```hcl +data "azurerm_avs_authorization" "example" { + name = "example-authorization" + resource_group_name = "example-resource-group" + private_cloud_name = "existing" +} + +output "id" { + value = data.azurerm_avs_authorization.example.id +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name of this avs Authorization. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs Authorization exists. + +* `private_cloud_name` - (Required) Name of the private cloud. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs Authorization. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `read` - (Defaults to 5 minutes) Used when retrieving the avs Authorization. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown new file mode 100644 index 000000000000..de1690c15cf9 --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown @@ -0,0 +1,47 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: Data Source: azurerm_avs_cluster" +description: |- + Gets information about an existing avs Cluster. +--- + +# Data Source: azurerm_avs_cluster + +Use this data source to access information about an existing avs Cluster. + +## Example Usage + +```hcl +data "azurerm_avs_cluster" "example" { + name = "example-cluster" + resource_group_name = "example-resource-group" + private_cloud_name = "existing" +} + +output "id" { + value = data.azurerm_avs_cluster.example.id +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name of this avs Cluster. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs Cluster exists. + +* `private_cloud_name` - (Required) Name of the private cloud. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs Cluster. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `read` - (Defaults to 5 minutes) Used when retrieving the avs Cluster. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown new file mode 100644 index 000000000000..6e18f0e9d375 --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown @@ -0,0 +1,47 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: Data Source: azurerm_avs_hcx_enterprise_site" +description: |- + Gets information about an existing avs HcxEnterpriseSite. +--- + +# Data Source: azurerm_avs_hcx_enterprise_site + +Use this data source to access information about an existing avs HcxEnterpriseSite. + +## Example Usage + +```hcl +data "azurerm_avs_hcx_enterprise_site" "example" { + name = "example-hcxenterprisesite" + resource_group_name = "example-resource-group" + private_cloud_name = "existing" +} + +output "id" { + value = data.azurerm_avs_hcx_enterprise_site.example.id +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name of this avs HcxEnterpriseSite. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs HcxEnterpriseSite exists. + +* `private_cloud_name` - (Required) Name of the private cloud. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs HcxEnterpriseSite. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `read` - (Defaults to 5 minutes) Used when retrieving the avs HcxEnterpriseSite. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown new file mode 100644 index 000000000000..38b17d1338ac --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown @@ -0,0 +1,48 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: Data Source: azurerm_avs_private_cloud" +description: |- + Gets information about an existing avs PrivateCloud. +--- + +# Data Source: azurerm_avs_private_cloud + +Use this data source to access information about an existing avs PrivateCloud. + +## Example Usage + +```hcl +data "azurerm_avs_private_cloud" "example" { + name = "example-privatecloud" + resource_group_name = "example-resource-group" +} + +output "id" { + value = data.azurerm_avs_private_cloud.example.id +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name of this avs PrivateCloud. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs PrivateCloud exists. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs PrivateCloud. + +* `location` - The Azure Region where the avs PrivateCloud exists. + +* `tags` - A mapping of tags assigned to the avs PrivateCloud. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `read` - (Defaults to 5 minutes) Used when retrieving the avs PrivateCloud. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown new file mode 100644 index 000000000000..d098815c1b57 --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown @@ -0,0 +1,78 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_avs_authorization" +description: |- + Manages a avs Authorization. +--- + +# azurerm_avs_authorization + +Manages a avs Authorization. + +## Example Usage + +```hcl +resource "azurerm_resource_group" "example" { + name = "example-resources" + location = "West Europe" +} + +resource "azurerm_avs_private_cloud" "example" { + name = "example-privatecloud" + resource_group_name = azurerm_resource_group.example.name + location = azurerm_resource_group.example.location + sku { + name = "example-privatecloud" + } + + management_cluster { + cluster_size = 42 + } + network_block = "" +} + +resource "azurerm_avs_authorization" "example" { + name = "example-authorization" + resource_group_name = azurerm_resource_group.example.name + private_cloud_name = azurerm_avs_private_cloud.example.name +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name which should be used for this avs Authorization. Changing this forces a new avs Authorization to be created. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs Authorization should exist. Changing this forces a new avs Authorization to be created. + +* `private_cloud_name` - (Required) The name of the private cloud. Changing this forces a new avs Authorization to be created. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs Authorization. + +* `express_route_authorization_id` - The ID of the express_route_authorization. + +* `express_route_authorization_key` - The key of the ExpressRoute Circuit Authorization. + +* `type` - Resource type. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `create` - (Defaults to 30 minutes) Used when creating the avs Authorization. +* `read` - (Defaults to 5 minutes) Used when retrieving the avs Authorization. +* `delete` - (Defaults to 30 minutes) Used when deleting the avs Authorization. + +## Import + +avs Authorizations can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_avs_authorization.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1 +``` \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown new file mode 100644 index 000000000000..f43b6c80c88d --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown @@ -0,0 +1,93 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_avs_cluster" +description: |- + Manages a avs Cluster. +--- + +# azurerm_avs_cluster + +Manages a avs Cluster. + +## Example Usage + +```hcl +resource "azurerm_resource_group" "example" { + name = "example-resources" + location = "West Europe" +} + +resource "azurerm_avs_private_cloud" "example" { + name = "example-privatecloud" + resource_group_name = azurerm_resource_group.example.name + location = azurerm_resource_group.example.location + sku { + name = "example-privatecloud" + } + + management_cluster { + cluster_size = 42 + } + network_block = "" +} + +resource "azurerm_avs_cluster" "example" { + name = "example-cluster" + resource_group_name = azurerm_resource_group.example.name + private_cloud_name = azurerm_avs_private_cloud.example.name + sku { + name = "example-cluster" + } + cluster_size = 42 +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name which should be used for this avs Cluster. Changing this forces a new avs Cluster to be created. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs Cluster should exist. Changing this forces a new avs Cluster to be created. + +* `private_cloud_name` - (Required) The name of the private cloud. Changing this forces a new avs Cluster to be created. + +* `sku` - (Required) A `sku` block as defined below. Changing this forces a new avs Cluster to be created. + +* `cluster_size` - (Required) The cluster size. + +--- + +An `sku` block exports the following: + +* `name` - (Required) The name which should be used for this sku. Changing this forces a new avs Cluster to be created. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs Cluster. + +* `cluster_id` - The ID of the cluster. + +* `hosts` - The hosts. + +* `type` - Resource type. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `create` - (Defaults to 30 minutes) Used when creating the avs Cluster. +* `read` - (Defaults to 5 minutes) Used when retrieving the avs Cluster. +* `update` - (Defaults to 30 minutes) Used when updating the avs Cluster. +* `delete` - (Defaults to 30 minutes) Used when deleting the avs Cluster. + +## Import + +avs Clusters can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_avs_cluster.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters/cluster1 +``` \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown new file mode 100644 index 000000000000..a7102f331b78 --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown @@ -0,0 +1,76 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_avs_hcx_enterprise_site" +description: |- + Manages a avs HcxEnterpriseSite. +--- + +# azurerm_avs_hcx_enterprise_site + +Manages a avs HcxEnterpriseSite. + +## Example Usage + +```hcl +resource "azurerm_resource_group" "example" { + name = "example-resources" + location = "West Europe" +} + +resource "azurerm_avs_private_cloud" "example" { + name = "example-privatecloud" + resource_group_name = azurerm_resource_group.example.name + location = azurerm_resource_group.example.location + sku { + name = "example-privatecloud" + } + + management_cluster { + cluster_size = 42 + } + network_block = "" +} + +resource "azurerm_avs_hcx_enterprise_site" "example" { + name = "example-hcxenterprisesite" + resource_group_name = azurerm_resource_group.example.name + private_cloud_name = azurerm_avs_private_cloud.example.name +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name which should be used for this avs HcxEnterpriseSite. Changing this forces a new avs HcxEnterpriseSite to be created. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs HcxEnterpriseSite should exist. Changing this forces a new avs HcxEnterpriseSite to be created. + +* `private_cloud_name` - (Required) The name of the private cloud. Changing this forces a new avs HcxEnterpriseSite to be created. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs HcxEnterpriseSite. + +* `activation_key` - The activation key. + +* `type` - Resource type. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `create` - (Defaults to 30 minutes) Used when creating the avs HcxEnterpriseSite. +* `read` - (Defaults to 5 minutes) Used when retrieving the avs HcxEnterpriseSite. +* `delete` - (Defaults to 30 minutes) Used when deleting the avs HcxEnterpriseSite. + +## Import + +avs HcxEnterpriseSites can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_avs_hcx_enterprise_site.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/hcxEnterpriseSites/hcxEnterpriseSite1 +``` \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown new file mode 100644 index 000000000000..099ec120d789 --- /dev/null +++ b/azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown @@ -0,0 +1,159 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_avs_private_cloud" +description: |- + Manages a avs PrivateCloud. +--- + +# azurerm_avs_private_cloud + +Manages a avs PrivateCloud. + +## Example Usage + +```hcl +resource "azurerm_resource_group" "example" { + name = "example-resources" + location = "West Europe" +} + +resource "azurerm_avs_private_cloud" "example" { + name = "example-privatecloud" + resource_group_name = azurerm_resource_group.example.name + location = azurerm_resource_group.example.location + sku { + name = "example-privatecloud" + } + + management_cluster { + cluster_size = 42 + } + network_block = "192.168.48.0/22" +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name which should be used for this avs PrivateCloud. Changing this forces a new avs PrivateCloud to be created. + +* `resource_group_name` - (Required) The name of the Resource Group where the avs PrivateCloud should exist. Changing this forces a new avs PrivateCloud to be created. + +* `location` - (Required) The Azure Region where the avs PrivateCloud should exist. Changing this forces a new avs PrivateCloud to be created. + +* `sku` - (Required) A `sku` block as defined below. Changing this forces a new avs PrivateCloud to be created. + +* `management_cluster` - (Required) A `management_cluster` block as defined below. + +* `network_block` - (Required) The block of addresses should be unique across VNet in your subscription as well as on-premise. Make sure the CIDR format is conformed to (A.B.C.D/X) where A,B,C,D are between 0 and 255, and X is between 0 and 22. + +--- + +* `identity_source` - (Optional) A `identity_source` block as defined below. + +* `internet` - (Optional) Connectivity to internet is enabled or disabled. Possible values are "true" and "false" is allowed. + +* `nsxt_password` - (Optional) Optionally, set the NSX-T Manager password when the private cloud is created. + +* `vcenter_password` - (Optional) Optionally, set the vCenter admin password when the private cloud is created. + +* `tags` - (Optional) A mapping of tags which should be assigned to the avs PrivateCloud. + +--- + +An `sku` block exports the following: + +* `name` - (Required) The name which should be used for this sku. Changing this forces a new avs PrivateCloud to be created. + +--- + +An `management_cluster` block exports the following: + +* `cluster_size` - (Required) The cluster size. + +--- + +An `identity_source` block exports the following: + +* `name` - (Optional) The name which should be used for this identity_source. + +* `alias` - (Optional) The domain's NetBIOS name. + +* `base_group_dn` - (Optional) The base distinguished name for groups. + +* `base_user_dn` - (Optional) The base distinguished name for users. + +* `domain` - (Optional) The domain's dns name. + +* `password` - (Optional) The password of the Active Directory user with a minimum of read-only access to Base DN for users and groups. + +* `primary_server` - (Optional) Primary server URL. + +* `secondary_server` - (Optional) Secondary server URL. + +* `ssl` - (Optional) Protect LDAP communication using SSL certificate (LDAPS). Possible values are "true" and "false" is allowed. + +* `username` - (Optional) The ID of an Active Directory user with a minimum of read-only access to Base DN for users and group. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the avs PrivateCloud. + +* `circuit` - An ExpressRoute Circuit. A `circuit` block as defined below. + +* `endpoint` - The endpoints. A `endpoint` block as defined below. + +* `management_network` - Network used to access vCenter Server and NSX-T Manager. + +* `nsxt_certificate_thumbprint` - Thumbprint of the NSX-T Manager SSL certificate. + +* `provisioning_network` - Used for virtual machine cold migration, cloning, and snapshot migration. + +* `type` - Resource type. + +* `vcenter_certificate_thumbprint` - Thumbprint of the vCenter Server SSL certificate. + +* `vmotion_network` - Used for live migration of virtual machines. + +--- + +An `circuit` block exports the following: + +* `express_route_id` - The ID of the express_route. + +* `express_route_private_peering_id` - The ID of the express_route_private_peering. + +* `primary_subnet` - CIDR of primary subnet. + +* `secondary_subnet` - CIDR of secondary subnet. + +--- + +An `endpoint` block exports the following: + +* `hcx_cloud_manager` - Endpoint for the HCX Cloud Manager. + +* `nsxt_manager` - Endpoint for the NSX-T Data Center manager. + +* `vcsa` - Endpoint for Virtual Center Server Appliance. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `create` - (Defaults to 30 minutes) Used when creating the avs PrivateCloud. +* `read` - (Defaults to 5 minutes) Used when retrieving the avs PrivateCloud. +* `update` - (Defaults to 30 minutes) Used when updating the avs PrivateCloud. +* `delete` - (Defaults to 30 minutes) Used when deleting the avs PrivateCloud. + +## Import + +avs PrivateClouds can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_avs_private_cloud.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1 +``` \ No newline at end of file diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go new file mode 100644 index 000000000000..e8cc967e2088 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go @@ -0,0 +1,432 @@ +package avs + +// 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" +) + +// AuthorizationsClient is the azure VMware Solution API +type AuthorizationsClient struct { + BaseClient +} + +// NewAuthorizationsClient creates an instance of the AuthorizationsClient client. +func NewAuthorizationsClient(subscriptionID string) AuthorizationsClient { + return NewAuthorizationsClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewAuthorizationsClientWithBaseURI creates an instance of the AuthorizationsClient 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 NewAuthorizationsClientWithBaseURI(baseURI string, subscriptionID string) AuthorizationsClient { + return AuthorizationsClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - the name of the private cloud. +// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud +// authorization - an ExpressRoute Circuit Authorization +func (client AuthorizationsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (result AuthorizationsCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, authorizationName, authorization) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client AuthorizationsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "authorizationName": autorest.Encode("path", authorizationName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/authorizations/{authorizationName}", pathParameters), + autorest.WithJSON(authorization), + 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 AuthorizationsClient) CreateOrUpdateSender(req *http.Request) (future AuthorizationsCreateOrUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client AuthorizationsClient) CreateOrUpdateResponder(resp *http.Response) (result ExpressRouteAuthorization, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud +func (client AuthorizationsClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result AuthorizationsDeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, authorizationName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client AuthorizationsClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "authorizationName": autorest.Encode("path", authorizationName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) DeleteSender(req *http.Request) (future AuthorizationsDeleteFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client AuthorizationsClient) 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 sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud +func (client AuthorizationsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result ExpressRouteAuthorization, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, authorizationName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client AuthorizationsClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "authorizationName": autorest.Encode("path", authorizationName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) 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 AuthorizationsClient) GetResponder(resp *http.Response) (result ExpressRouteAuthorization, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client AuthorizationsClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result ExpressRouteAuthorizationListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.List") + defer func() { + sc := -1 + if result.eral.Response.Response != nil { + sc = result.eral.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.eral.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", resp, "Failure sending request") + return + } + + result.eral, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", resp, "Failure responding to request") + } + if result.eral.hasNextLink() && result.eral.IsEmpty() { + err = result.NextWithContext(ctx) + } + + return +} + +// ListPreparer prepares the List request. +func (client AuthorizationsClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) 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 AuthorizationsClient) ListResponder(resp *http.Response) (result ExpressRouteAuthorizationList, 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 AuthorizationsClient) listNextResults(ctx context.Context, lastResults ExpressRouteAuthorizationList) (result ExpressRouteAuthorizationList, err error) { + req, err := lastResults.expressRouteAuthorizationListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "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, "avs.AuthorizationsClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client AuthorizationsClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result ExpressRouteAuthorizationListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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, privateCloudName) + return +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go new file mode 100644 index 000000000000..eb7087c9474a --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go @@ -0,0 +1,89 @@ +package avsapi + +// 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/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" + "github.com/Azure/go-autorest/autorest" +) + +// OperationsClientAPI contains the set of methods on the OperationsClient type. +type OperationsClientAPI interface { + List(ctx context.Context) (result avs.OperationListPage, err error) + ListComplete(ctx context.Context) (result avs.OperationListIterator, err error) +} + +var _ OperationsClientAPI = (*avs.OperationsClient)(nil) + +// LocationsClientAPI contains the set of methods on the LocationsClient type. +type LocationsClientAPI interface { + CheckQuotaAvailability(ctx context.Context, location string) (result avs.Quota, err error) + CheckTrialAvailability(ctx context.Context, location string) (result avs.Trial, err error) +} + +var _ LocationsClientAPI = (*avs.LocationsClient)(nil) + +// PrivateCloudsClientAPI contains the set of methods on the PrivateCloudsClient type. +type PrivateCloudsClientAPI interface { + CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud avs.PrivateCloud) (result avs.PrivateCloudsCreateOrUpdateFuture, err error) + Delete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.PrivateCloudsDeleteFuture, err error) + Get(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.PrivateCloud, err error) + List(ctx context.Context, resourceGroupName string) (result avs.PrivateCloudListPage, err error) + ListComplete(ctx context.Context, resourceGroupName string) (result avs.PrivateCloudListIterator, err error) + ListAdminCredentials(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.AdminCredentials, err error) + ListInSubscription(ctx context.Context) (result avs.PrivateCloudListPage, err error) + ListInSubscriptionComplete(ctx context.Context) (result avs.PrivateCloudListIterator, err error) + Update(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate avs.PrivateCloudUpdate) (result avs.PrivateCloudsUpdateFuture, err error) +} + +var _ PrivateCloudsClientAPI = (*avs.PrivateCloudsClient)(nil) + +// ClustersClientAPI contains the set of methods on the ClustersClient type. +type ClustersClientAPI interface { + CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster avs.Cluster) (result avs.ClustersCreateOrUpdateFuture, err error) + Delete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result avs.ClustersDeleteFuture, err error) + Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result avs.Cluster, err error) + List(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ClusterListPage, err error) + ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ClusterListIterator, err error) + Update(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate avs.ClusterUpdate) (result avs.ClustersUpdateFuture, err error) +} + +var _ ClustersClientAPI = (*avs.ClustersClient)(nil) + +// HcxEnterpriseSitesClientAPI contains the set of methods on the HcxEnterpriseSitesClient type. +type HcxEnterpriseSitesClientAPI interface { + CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (result avs.HcxEnterpriseSite, err error) + Delete(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result autorest.Response, err error) + Get(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result avs.HcxEnterpriseSite, err error) + List(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.HcxEnterpriseSiteListPage, err error) + ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.HcxEnterpriseSiteListIterator, err error) +} + +var _ HcxEnterpriseSitesClientAPI = (*avs.HcxEnterpriseSitesClient)(nil) + +// AuthorizationsClientAPI contains the set of methods on the AuthorizationsClient type. +type AuthorizationsClientAPI interface { + CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (result avs.AuthorizationsCreateOrUpdateFuture, err error) + Delete(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result avs.AuthorizationsDeleteFuture, err error) + Get(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result avs.ExpressRouteAuthorization, err error) + List(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ExpressRouteAuthorizationListPage, err error) + ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ExpressRouteAuthorizationListIterator, err error) +} + +var _ AuthorizationsClientAPI = (*avs.AuthorizationsClient)(nil) diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go new file mode 100644 index 000000000000..f9b3fc4c05b3 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go @@ -0,0 +1,52 @@ +// Package avs implements the Azure ARM Avs service API version 2020-03-20. +// +// Azure VMware Solution API +package avs + +// 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 Avs + DefaultBaseURI = "https://management.azure.com" +) + +// BaseClient is the base client for Avs. +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/avs/mgmt/2020-03-20/avs/clusters.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/clusters.go new file mode 100644 index 000000000000..fb28755b2d24 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/clusters.go @@ -0,0 +1,526 @@ +package avs + +// 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" +) + +// ClustersClient is the azure VMware Solution API +type ClustersClient struct { + BaseClient +} + +// NewClustersClient creates an instance of the ClustersClient client. +func NewClustersClient(subscriptionID string) ClustersClient { + return NewClustersClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewClustersClientWithBaseURI creates an instance of the ClustersClient 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 NewClustersClientWithBaseURI(baseURI string, subscriptionID string) ClustersClient { + return ClustersClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - the name of the private cloud. +// clusterName - name of the cluster in the private cloud +// cluster - a cluster in the private cloud +func (client ClustersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster Cluster) (result ClustersCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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: cluster, + Constraints: []validation.Constraint{{Target: "cluster.Sku", Name: validation.Null, Rule: true, + Chain: []validation.Constraint{{Target: "cluster.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}, + {Target: "cluster.ClusterProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.ClustersClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, clusterName, cluster) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client ClustersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster Cluster) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", pathParameters), + autorest.WithJSON(cluster), + 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 ClustersClient) CreateOrUpdateSender(req *http.Request) (future ClustersCreateOrUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client ClustersClient) CreateOrUpdateResponder(resp *http.Response) (result Cluster, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// clusterName - name of the cluster in the private cloud +func (client ClustersClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result ClustersDeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, clusterName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client ClustersClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", 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 ClustersClient) DeleteSender(req *http.Request) (future ClustersDeleteFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client ClustersClient) 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 sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// clusterName - name of the cluster in the private cloud +func (client ClustersClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result Cluster, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, clusterName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client ClustersClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", 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 ClustersClient) 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 ClustersClient) GetResponder(resp *http.Response) (result Cluster, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client ClustersClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result ClusterListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.List") + defer func() { + sc := -1 + if result.cl.Response.Response != nil { + sc = result.cl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.cl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", resp, "Failure sending request") + return + } + + result.cl, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", resp, "Failure responding to request") + } + if result.cl.hasNextLink() && result.cl.IsEmpty() { + err = result.NextWithContext(ctx) + } + + return +} + +// ListPreparer prepares the List request. +func (client ClustersClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters", 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 ClustersClient) 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 ClustersClient) ListResponder(resp *http.Response) (result ClusterList, 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 ClustersClient) listNextResults(ctx context.Context, lastResults ClusterList) (result ClusterList, err error) { + req, err := lastResults.clusterListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.ClustersClient", "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, "avs.ClustersClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client ClustersClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result ClusterListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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, privateCloudName) + return +} + +// Update sends the update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// clusterName - name of the cluster in the private cloud +// clusterUpdate - the cluster properties to be updated +func (client ClustersClient) Update(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate ClusterUpdate) (result ClustersUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "Update", err.Error()) + } + + req, err := client.UpdatePreparer(ctx, resourceGroupName, privateCloudName, clusterName, clusterUpdate) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Update", nil, "Failure preparing request") + return + } + + result, err = client.UpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Update", result.Response(), "Failure sending request") + return + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client ClustersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate ClusterUpdate) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", pathParameters), + autorest.WithJSON(clusterUpdate), + 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 ClustersClient) UpdateSender(req *http.Request) (future ClustersUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client ClustersClient) UpdateResponder(resp *http.Response) (result Cluster, 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/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go new file mode 100644 index 000000000000..f04bbdee504f --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go @@ -0,0 +1,433 @@ +package avs + +// 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" +) + +// HcxEnterpriseSitesClient is the azure VMware Solution API +type HcxEnterpriseSitesClient struct { + BaseClient +} + +// NewHcxEnterpriseSitesClient creates an instance of the HcxEnterpriseSitesClient client. +func NewHcxEnterpriseSitesClient(subscriptionID string) HcxEnterpriseSitesClient { + return NewHcxEnterpriseSitesClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewHcxEnterpriseSitesClientWithBaseURI creates an instance of the HcxEnterpriseSitesClient 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 NewHcxEnterpriseSitesClientWithBaseURI(baseURI string, subscriptionID string) HcxEnterpriseSitesClient { + return HcxEnterpriseSitesClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - the name of the private cloud. +// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud +// hcxEnterpriseSite - the HCX Enterprise Site +func (client HcxEnterpriseSitesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (result HcxEnterpriseSite, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.CreateOrUpdate") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName, hcxEnterpriseSite) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + resp, err := client.CreateOrUpdateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", resp, "Failure sending request") + return + } + + result, err = client.CreateOrUpdateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", resp, "Failure responding to request") + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client HcxEnterpriseSitesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", pathParameters), + autorest.WithJSON(hcxEnterpriseSite), + 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) CreateOrUpdateResponder(resp *http.Response) (result HcxEnterpriseSite, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud +func (client HcxEnterpriseSitesClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", resp, "Failure responding to request") + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client HcxEnterpriseSitesClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) 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 +} + +// Get sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud +func (client HcxEnterpriseSitesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result HcxEnterpriseSite, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client HcxEnterpriseSitesClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) GetResponder(resp *http.Response) (result HcxEnterpriseSite, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client HcxEnterpriseSitesClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result HcxEnterpriseSiteListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.List") + defer func() { + sc := -1 + if result.hesl.Response.Response != nil { + sc = result.hesl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.hesl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", resp, "Failure sending request") + return + } + + result.hesl, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", resp, "Failure responding to request") + } + if result.hesl.hasNextLink() && result.hesl.IsEmpty() { + err = result.NextWithContext(ctx) + } + + return +} + +// ListPreparer prepares the List request. +func (client HcxEnterpriseSitesClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) ListResponder(resp *http.Response) (result HcxEnterpriseSiteList, 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 HcxEnterpriseSitesClient) listNextResults(ctx context.Context, lastResults HcxEnterpriseSiteList) (result HcxEnterpriseSiteList, err error) { + req, err := lastResults.hcxEnterpriseSiteListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "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, "avs.HcxEnterpriseSitesClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client HcxEnterpriseSitesClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result HcxEnterpriseSiteListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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, privateCloudName) + return +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go new file mode 100644 index 000000000000..1a3f5032a634 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go @@ -0,0 +1,201 @@ +package avs + +// 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" +) + +// LocationsClient is the azure VMware Solution API +type LocationsClient struct { + BaseClient +} + +// NewLocationsClient creates an instance of the LocationsClient client. +func NewLocationsClient(subscriptionID string) LocationsClient { + return NewLocationsClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewLocationsClientWithBaseURI creates an instance of the LocationsClient 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 NewLocationsClientWithBaseURI(baseURI string, subscriptionID string) LocationsClient { + return LocationsClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CheckQuotaAvailability return quota for subscription by region +// Parameters: +// location - azure region +func (client LocationsClient) CheckQuotaAvailability(ctx context.Context, location string) (result Quota, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LocationsClient.CheckQuotaAvailability") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.LocationsClient", "CheckQuotaAvailability", err.Error()) + } + + req, err := client.CheckQuotaAvailabilityPreparer(ctx, location) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", nil, "Failure preparing request") + return + } + + resp, err := client.CheckQuotaAvailabilitySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", resp, "Failure sending request") + return + } + + result, err = client.CheckQuotaAvailabilityResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", resp, "Failure responding to request") + } + + return +} + +// CheckQuotaAvailabilityPreparer prepares the CheckQuotaAvailability request. +func (client LocationsClient) CheckQuotaAvailabilityPreparer(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 = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/locations/{location}/checkQuotaAvailability", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CheckQuotaAvailabilitySender sends the CheckQuotaAvailability request. The method will close the +// http.Response Body if it receives an error. +func (client LocationsClient) CheckQuotaAvailabilitySender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// CheckQuotaAvailabilityResponder handles the response to the CheckQuotaAvailability request. The method always +// closes the http.Response Body. +func (client LocationsClient) CheckQuotaAvailabilityResponder(resp *http.Response) (result Quota, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// CheckTrialAvailability return trial status for subscription by region +// Parameters: +// location - azure region +func (client LocationsClient) CheckTrialAvailability(ctx context.Context, location string) (result Trial, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LocationsClient.CheckTrialAvailability") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.LocationsClient", "CheckTrialAvailability", err.Error()) + } + + req, err := client.CheckTrialAvailabilityPreparer(ctx, location) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", nil, "Failure preparing request") + return + } + + resp, err := client.CheckTrialAvailabilitySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", resp, "Failure sending request") + return + } + + result, err = client.CheckTrialAvailabilityResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", resp, "Failure responding to request") + } + + return +} + +// CheckTrialAvailabilityPreparer prepares the CheckTrialAvailability request. +func (client LocationsClient) CheckTrialAvailabilityPreparer(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 = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/locations/{location}/checkTrialAvailability", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CheckTrialAvailabilitySender sends the CheckTrialAvailability request. The method will close the +// http.Response Body if it receives an error. +func (client LocationsClient) CheckTrialAvailabilitySender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// CheckTrialAvailabilityResponder handles the response to the CheckTrialAvailability request. The method always +// closes the http.Response Body. +func (client LocationsClient) CheckTrialAvailabilityResponder(resp *http.Response) (result Trial, 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/avs/mgmt/2020-03-20/avs/models.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/models.go new file mode 100644 index 000000000000..26c10c261f3a --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/models.go @@ -0,0 +1,1770 @@ +package avs + +// 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/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/avs/mgmt/2020-03-20/avs" + +// AdminCredentials administrative credentials for accessing vCenter and NSX-T +type AdminCredentials struct { + autorest.Response `json:"-"` + // NsxtUsername - READ-ONLY; NSX-T Manager username + NsxtUsername *string `json:"nsxtUsername,omitempty"` + // NsxtPassword - READ-ONLY; NSX-T Manager password + NsxtPassword *string `json:"nsxtPassword,omitempty"` + // VcenterUsername - READ-ONLY; vCenter admin username + VcenterUsername *string `json:"vcenterUsername,omitempty"` + // VcenterPassword - READ-ONLY; vCenter admin password + VcenterPassword *string `json:"vcenterPassword,omitempty"` +} + +// AuthorizationsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. +type AuthorizationsCreateOrUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *AuthorizationsCreateOrUpdateFuture) Result(client AuthorizationsClient) (era ExpressRouteAuthorization, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.AuthorizationsCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if era.Response.Response, err = future.GetResult(sender); err == nil && era.Response.Response.StatusCode != http.StatusNoContent { + era, err = client.CreateOrUpdateResponder(era.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsCreateOrUpdateFuture", "Result", era.Response.Response, "Failure responding to request") + } + } + return +} + +// AuthorizationsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type AuthorizationsDeleteFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *AuthorizationsDeleteFuture) Result(client AuthorizationsClient) (ar autorest.Response, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsDeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.AuthorizationsDeleteFuture") + return + } + ar.Response = future.Response() + return +} + +// Circuit an ExpressRoute Circuit +type Circuit struct { + // PrimarySubnet - READ-ONLY; CIDR of primary subnet + PrimarySubnet *string `json:"primarySubnet,omitempty"` + // SecondarySubnet - READ-ONLY; CIDR of secondary subnet + SecondarySubnet *string `json:"secondarySubnet,omitempty"` + // ExpressRouteID - READ-ONLY; Identifier of the ExpressRoute Circuit (Microsoft Colo only) + ExpressRouteID *string `json:"expressRouteID,omitempty"` + // ExpressRoutePrivatePeeringID - READ-ONLY; ExpressRoute Circuit private peering identifier + ExpressRoutePrivatePeeringID *string `json:"expressRoutePrivatePeeringID,omitempty"` +} + +// CloudError API error response +type CloudError struct { + // Error - An error returned by the API + Error *ErrorResponse `json:"error,omitempty"` +} + +// Cluster a cluster resource +type Cluster struct { + autorest.Response `json:"-"` + // Sku - The cluster SKU + Sku *Sku `json:"sku,omitempty"` + // ClusterProperties - The properties of a cluster resource + *ClusterProperties `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"` +} + +// MarshalJSON is the custom marshaler for Cluster. +func (c Cluster) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if c.Sku != nil { + objectMap["sku"] = c.Sku + } + if c.ClusterProperties != nil { + objectMap["properties"] = c.ClusterProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for Cluster struct. +func (c *Cluster) 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 + } + c.Sku = &sku + } + case "properties": + if v != nil { + var clusterProperties ClusterProperties + err = json.Unmarshal(*v, &clusterProperties) + if err != nil { + return err + } + c.ClusterProperties = &clusterProperties + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + c.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + c.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + c.Type = &typeVar + } + } + } + + return nil +} + +// ClusterList a paged list of clusters +type ClusterList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on a page + Value *[]Cluster `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// ClusterListIterator provides access to a complete listing of Cluster values. +type ClusterListIterator struct { + i int + page ClusterListPage +} + +// 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 *ClusterListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClusterListIterator.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 *ClusterListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter ClusterListIterator) 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 ClusterListIterator) Response() ClusterList { + 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 ClusterListIterator) Value() Cluster { + if !iter.page.NotDone() { + return Cluster{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the ClusterListIterator type. +func NewClusterListIterator(page ClusterListPage) ClusterListIterator { + return ClusterListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (cl ClusterList) IsEmpty() bool { + return cl.Value == nil || len(*cl.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (cl ClusterList) hasNextLink() bool { + return cl.NextLink != nil && len(*cl.NextLink) != 0 +} + +// clusterListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (cl ClusterList) clusterListPreparer(ctx context.Context) (*http.Request, error) { + if !cl.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(cl.NextLink))) +} + +// ClusterListPage contains a page of Cluster values. +type ClusterListPage struct { + fn func(context.Context, ClusterList) (ClusterList, error) + cl ClusterList +} + +// 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 *ClusterListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClusterListPage.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.cl) + if err != nil { + return err + } + page.cl = 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 *ClusterListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page ClusterListPage) NotDone() bool { + return !page.cl.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page ClusterListPage) Response() ClusterList { + return page.cl +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page ClusterListPage) Values() []Cluster { + if page.cl.IsEmpty() { + return nil + } + return *page.cl.Value +} + +// Creates a new instance of the ClusterListPage type. +func NewClusterListPage(getNextPage func(context.Context, ClusterList) (ClusterList, error)) ClusterListPage { + return ClusterListPage{fn: getNextPage} +} + +// ClusterProperties the properties of a cluster +type ClusterProperties struct { + // ProvisioningState - READ-ONLY; The state of the cluster provisioning. Possible values include: 'Succeeded', 'Failed', 'Cancelled', 'Deleting', 'Updating' + ProvisioningState ClusterProvisioningState `json:"provisioningState,omitempty"` + // ClusterID - READ-ONLY; The identity + ClusterID *int32 `json:"clusterId,omitempty"` + // Hosts - READ-ONLY; The hosts + Hosts *[]string `json:"hosts,omitempty"` + // ClusterSize - The cluster size + ClusterSize *int32 `json:"clusterSize,omitempty"` +} + +// MarshalJSON is the custom marshaler for ClusterProperties. +func (cp ClusterProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if cp.ClusterSize != nil { + objectMap["clusterSize"] = cp.ClusterSize + } + return json.Marshal(objectMap) +} + +// ClustersCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type ClustersCreateOrUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *ClustersCreateOrUpdateFuture) Result(client ClustersClient) (c Cluster, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.ClustersCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { + c, err = client.CreateOrUpdateResponder(c.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersCreateOrUpdateFuture", "Result", c.Response.Response, "Failure responding to request") + } + } + return +} + +// ClustersDeleteFuture an abstraction for monitoring and retrieving the results of a long-running operation. +type ClustersDeleteFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *ClustersDeleteFuture) Result(client ClustersClient) (ar autorest.Response, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersDeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.ClustersDeleteFuture") + return + } + ar.Response = future.Response() + return +} + +// ClustersUpdateFuture an abstraction for monitoring and retrieving the results of a long-running operation. +type ClustersUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *ClustersUpdateFuture) Result(client ClustersClient) (c Cluster, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.ClustersUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { + c, err = client.UpdateResponder(c.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersUpdateFuture", "Result", c.Response.Response, "Failure responding to request") + } + } + return +} + +// ClusterUpdate an update of a cluster resource +type ClusterUpdate struct { + // ClusterUpdateProperties - The properties of a cluster resource that may be updated + *ClusterUpdateProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for ClusterUpdate. +func (cu ClusterUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if cu.ClusterUpdateProperties != nil { + objectMap["properties"] = cu.ClusterUpdateProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for ClusterUpdate struct. +func (cu *ClusterUpdate) 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 clusterUpdateProperties ClusterUpdateProperties + err = json.Unmarshal(*v, &clusterUpdateProperties) + if err != nil { + return err + } + cu.ClusterUpdateProperties = &clusterUpdateProperties + } + } + } + + return nil +} + +// ClusterUpdateProperties the properties of a cluster that may be updated +type ClusterUpdateProperties struct { + // ClusterSize - The cluster size + ClusterSize *int32 `json:"clusterSize,omitempty"` +} + +// Endpoints endpoint addresses +type Endpoints struct { + // NsxtManager - READ-ONLY; Endpoint for the NSX-T Data Center manager + NsxtManager *string `json:"nsxtManager,omitempty"` + // Vcsa - READ-ONLY; Endpoint for Virtual Center Server Appliance + Vcsa *string `json:"vcsa,omitempty"` + // HcxCloudManager - READ-ONLY; Endpoint for the HCX Cloud Manager + HcxCloudManager *string `json:"hcxCloudManager,omitempty"` +} + +// ErrorAdditionalInfo the resource management error additional info. +type ErrorAdditionalInfo struct { + // Type - READ-ONLY; The additional info type. + Type *string `json:"type,omitempty"` + // Info - READ-ONLY; The additional info. + Info interface{} `json:"info,omitempty"` +} + +// ErrorResponse the resource management error response. +type ErrorResponse struct { + // Code - READ-ONLY; The error code. + Code *string `json:"code,omitempty"` + // Message - READ-ONLY; The error message. + Message *string `json:"message,omitempty"` + // Target - READ-ONLY; The error target. + Target *string `json:"target,omitempty"` + // Details - READ-ONLY; The error details. + Details *[]ErrorResponse `json:"details,omitempty"` + // AdditionalInfo - READ-ONLY; The error additional info. + AdditionalInfo *[]ErrorAdditionalInfo `json:"additionalInfo,omitempty"` +} + +// ExpressRouteAuthorization expressRoute Circuit Authorization +type ExpressRouteAuthorization struct { + autorest.Response `json:"-"` + // ExpressRouteAuthorizationProperties - The properties of an ExpressRoute Circuit Authorization resource + *ExpressRouteAuthorizationProperties `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"` +} + +// MarshalJSON is the custom marshaler for ExpressRouteAuthorization. +func (era ExpressRouteAuthorization) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if era.ExpressRouteAuthorizationProperties != nil { + objectMap["properties"] = era.ExpressRouteAuthorizationProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for ExpressRouteAuthorization struct. +func (era *ExpressRouteAuthorization) 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 expressRouteAuthorizationProperties ExpressRouteAuthorizationProperties + err = json.Unmarshal(*v, &expressRouteAuthorizationProperties) + if err != nil { + return err + } + era.ExpressRouteAuthorizationProperties = &expressRouteAuthorizationProperties + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + era.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + era.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + era.Type = &typeVar + } + } + } + + return nil +} + +// ExpressRouteAuthorizationList a paged list of ExpressRoute Circuit Authorizations +type ExpressRouteAuthorizationList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on a page + Value *[]ExpressRouteAuthorization `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// ExpressRouteAuthorizationListIterator provides access to a complete listing of ExpressRouteAuthorization +// values. +type ExpressRouteAuthorizationListIterator struct { + i int + page ExpressRouteAuthorizationListPage +} + +// 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 *ExpressRouteAuthorizationListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteAuthorizationListIterator.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 *ExpressRouteAuthorizationListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter ExpressRouteAuthorizationListIterator) 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 ExpressRouteAuthorizationListIterator) Response() ExpressRouteAuthorizationList { + 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 ExpressRouteAuthorizationListIterator) Value() ExpressRouteAuthorization { + if !iter.page.NotDone() { + return ExpressRouteAuthorization{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the ExpressRouteAuthorizationListIterator type. +func NewExpressRouteAuthorizationListIterator(page ExpressRouteAuthorizationListPage) ExpressRouteAuthorizationListIterator { + return ExpressRouteAuthorizationListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (eral ExpressRouteAuthorizationList) IsEmpty() bool { + return eral.Value == nil || len(*eral.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (eral ExpressRouteAuthorizationList) hasNextLink() bool { + return eral.NextLink != nil && len(*eral.NextLink) != 0 +} + +// expressRouteAuthorizationListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (eral ExpressRouteAuthorizationList) expressRouteAuthorizationListPreparer(ctx context.Context) (*http.Request, error) { + if !eral.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(eral.NextLink))) +} + +// ExpressRouteAuthorizationListPage contains a page of ExpressRouteAuthorization values. +type ExpressRouteAuthorizationListPage struct { + fn func(context.Context, ExpressRouteAuthorizationList) (ExpressRouteAuthorizationList, error) + eral ExpressRouteAuthorizationList +} + +// 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 *ExpressRouteAuthorizationListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteAuthorizationListPage.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.eral) + if err != nil { + return err + } + page.eral = 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 *ExpressRouteAuthorizationListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page ExpressRouteAuthorizationListPage) NotDone() bool { + return !page.eral.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page ExpressRouteAuthorizationListPage) Response() ExpressRouteAuthorizationList { + return page.eral +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page ExpressRouteAuthorizationListPage) Values() []ExpressRouteAuthorization { + if page.eral.IsEmpty() { + return nil + } + return *page.eral.Value +} + +// Creates a new instance of the ExpressRouteAuthorizationListPage type. +func NewExpressRouteAuthorizationListPage(getNextPage func(context.Context, ExpressRouteAuthorizationList) (ExpressRouteAuthorizationList, error)) ExpressRouteAuthorizationListPage { + return ExpressRouteAuthorizationListPage{fn: getNextPage} +} + +// ExpressRouteAuthorizationProperties the properties of an ExpressRoute Circuit Authorization resource +type ExpressRouteAuthorizationProperties struct { + // ProvisioningState - READ-ONLY; The state of the ExpressRoute Circuit Authorization provisioning. Possible values include: 'ExpressRouteAuthorizationProvisioningStateSucceeded', 'ExpressRouteAuthorizationProvisioningStateFailed', 'ExpressRouteAuthorizationProvisioningStateUpdating' + ProvisioningState ExpressRouteAuthorizationProvisioningState `json:"provisioningState,omitempty"` + // ExpressRouteAuthorizationID - READ-ONLY; The ID of the ExpressRoute Circuit Authorization + ExpressRouteAuthorizationID *string `json:"expressRouteAuthorizationId,omitempty"` + // ExpressRouteAuthorizationKey - READ-ONLY; The key of the ExpressRoute Circuit Authorization + ExpressRouteAuthorizationKey *string `json:"expressRouteAuthorizationKey,omitempty"` +} + +// HcxEnterpriseSite an HCX Enterprise Site resource +type HcxEnterpriseSite struct { + autorest.Response `json:"-"` + // HcxEnterpriseSiteProperties - The properties of an HCX Enterprise Site resource + *HcxEnterpriseSiteProperties `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"` +} + +// MarshalJSON is the custom marshaler for HcxEnterpriseSite. +func (hes HcxEnterpriseSite) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if hes.HcxEnterpriseSiteProperties != nil { + objectMap["properties"] = hes.HcxEnterpriseSiteProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for HcxEnterpriseSite struct. +func (hes *HcxEnterpriseSite) 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 hcxEnterpriseSiteProperties HcxEnterpriseSiteProperties + err = json.Unmarshal(*v, &hcxEnterpriseSiteProperties) + if err != nil { + return err + } + hes.HcxEnterpriseSiteProperties = &hcxEnterpriseSiteProperties + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + hes.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + hes.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + hes.Type = &typeVar + } + } + } + + return nil +} + +// HcxEnterpriseSiteList a paged list of HCX Enterprise Sites +type HcxEnterpriseSiteList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on a page + Value *[]HcxEnterpriseSite `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// HcxEnterpriseSiteListIterator provides access to a complete listing of HcxEnterpriseSite values. +type HcxEnterpriseSiteListIterator struct { + i int + page HcxEnterpriseSiteListPage +} + +// 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 *HcxEnterpriseSiteListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSiteListIterator.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 *HcxEnterpriseSiteListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter HcxEnterpriseSiteListIterator) 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 HcxEnterpriseSiteListIterator) Response() HcxEnterpriseSiteList { + 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 HcxEnterpriseSiteListIterator) Value() HcxEnterpriseSite { + if !iter.page.NotDone() { + return HcxEnterpriseSite{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the HcxEnterpriseSiteListIterator type. +func NewHcxEnterpriseSiteListIterator(page HcxEnterpriseSiteListPage) HcxEnterpriseSiteListIterator { + return HcxEnterpriseSiteListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (hesl HcxEnterpriseSiteList) IsEmpty() bool { + return hesl.Value == nil || len(*hesl.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (hesl HcxEnterpriseSiteList) hasNextLink() bool { + return hesl.NextLink != nil && len(*hesl.NextLink) != 0 +} + +// hcxEnterpriseSiteListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (hesl HcxEnterpriseSiteList) hcxEnterpriseSiteListPreparer(ctx context.Context) (*http.Request, error) { + if !hesl.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(hesl.NextLink))) +} + +// HcxEnterpriseSiteListPage contains a page of HcxEnterpriseSite values. +type HcxEnterpriseSiteListPage struct { + fn func(context.Context, HcxEnterpriseSiteList) (HcxEnterpriseSiteList, error) + hesl HcxEnterpriseSiteList +} + +// 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 *HcxEnterpriseSiteListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSiteListPage.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.hesl) + if err != nil { + return err + } + page.hesl = 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 *HcxEnterpriseSiteListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page HcxEnterpriseSiteListPage) NotDone() bool { + return !page.hesl.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page HcxEnterpriseSiteListPage) Response() HcxEnterpriseSiteList { + return page.hesl +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page HcxEnterpriseSiteListPage) Values() []HcxEnterpriseSite { + if page.hesl.IsEmpty() { + return nil + } + return *page.hesl.Value +} + +// Creates a new instance of the HcxEnterpriseSiteListPage type. +func NewHcxEnterpriseSiteListPage(getNextPage func(context.Context, HcxEnterpriseSiteList) (HcxEnterpriseSiteList, error)) HcxEnterpriseSiteListPage { + return HcxEnterpriseSiteListPage{fn: getNextPage} +} + +// HcxEnterpriseSiteProperties the properties of an HCX Enterprise Site +type HcxEnterpriseSiteProperties struct { + // ActivationKey - READ-ONLY; The activation key + ActivationKey *string `json:"activationKey,omitempty"` + // Status - READ-ONLY; The status of the HCX Enterprise Site. Possible values include: 'Available', 'Consumed', 'Deactivated', 'Deleted' + Status HcxEnterpriseSiteStatus `json:"status,omitempty"` +} + +// IdentitySource vCenter Single Sign On Identity Source +type IdentitySource struct { + // Name - The name of the identity source + Name *string `json:"name,omitempty"` + // Alias - The domain's NetBIOS name + Alias *string `json:"alias,omitempty"` + // Domain - The domain's dns name + Domain *string `json:"domain,omitempty"` + // BaseUserDN - The base distinguished name for users + BaseUserDN *string `json:"baseUserDN,omitempty"` + // BaseGroupDN - The base distinguished name for groups + BaseGroupDN *string `json:"baseGroupDN,omitempty"` + // PrimaryServer - Primary server URL + PrimaryServer *string `json:"primaryServer,omitempty"` + // SecondaryServer - Secondary server URL + SecondaryServer *string `json:"secondaryServer,omitempty"` + // Ssl - Protect LDAP communication using SSL certificate (LDAPS). Possible values include: 'SslEnumEnabled', 'SslEnumDisabled' + Ssl SslEnum `json:"ssl,omitempty"` + // Username - The ID of an Active Directory user with a minimum of read-only access to Base DN for users and group + Username *string `json:"username,omitempty"` + // Password - The password of the Active Directory user with a minimum of read-only access to Base DN for users and groups. + Password *string `json:"password,omitempty"` +} + +// ManagementCluster the properties of a default cluster +type ManagementCluster struct { + // ClusterID - READ-ONLY; The identity + ClusterID *int32 `json:"clusterId,omitempty"` + // Hosts - READ-ONLY; The hosts + Hosts *[]string `json:"hosts,omitempty"` + // ClusterSize - The cluster size + ClusterSize *int32 `json:"clusterSize,omitempty"` +} + +// MarshalJSON is the custom marshaler for ManagementCluster. +func (mc ManagementCluster) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if mc.ClusterSize != nil { + objectMap["clusterSize"] = mc.ClusterSize + } + return json.Marshal(objectMap) +} + +// Operation a REST API operation +type Operation struct { + // Name - READ-ONLY; Name of the operation being performed on this object + Name *string `json:"name,omitempty"` + // Display - READ-ONLY; Contains the localized display information for this operation + Display *OperationDisplay `json:"display,omitempty"` +} + +// OperationDisplay contains the localized display information for this operation +type OperationDisplay struct { + // Provider - READ-ONLY; Localized friendly form of the resource provider name + Provider *string `json:"provider,omitempty"` + // Resource - READ-ONLY; Localized friendly form of the resource type related to this operation + Resource *string `json:"resource,omitempty"` + // Operation - READ-ONLY; Localized friendly name for the operation + Operation *string `json:"operation,omitempty"` + // Description - READ-ONLY; Localized friendly description for the operation + Description *string `json:"description,omitempty"` +} + +// OperationList pageable list of operations +type OperationList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; List of operations + Value *[]Operation `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// OperationListIterator provides access to a complete listing of Operation values. +type OperationListIterator struct { + i int + page OperationListPage +} + +// 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 *OperationListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationListIterator.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 *OperationListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter OperationListIterator) 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 OperationListIterator) Response() OperationList { + 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 OperationListIterator) Value() Operation { + if !iter.page.NotDone() { + return Operation{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the OperationListIterator type. +func NewOperationListIterator(page OperationListPage) OperationListIterator { + return OperationListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (ol OperationList) IsEmpty() bool { + return ol.Value == nil || len(*ol.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (ol OperationList) hasNextLink() bool { + return ol.NextLink != nil && len(*ol.NextLink) != 0 +} + +// operationListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (ol OperationList) operationListPreparer(ctx context.Context) (*http.Request, error) { + if !ol.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(ol.NextLink))) +} + +// OperationListPage contains a page of Operation values. +type OperationListPage struct { + fn func(context.Context, OperationList) (OperationList, error) + ol OperationList +} + +// 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 *OperationListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationListPage.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.ol) + if err != nil { + return err + } + page.ol = 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 *OperationListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page OperationListPage) NotDone() bool { + return !page.ol.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page OperationListPage) Response() OperationList { + return page.ol +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page OperationListPage) Values() []Operation { + if page.ol.IsEmpty() { + return nil + } + return *page.ol.Value +} + +// Creates a new instance of the OperationListPage type. +func NewOperationListPage(getNextPage func(context.Context, OperationList) (OperationList, error)) OperationListPage { + return OperationListPage{fn: getNextPage} +} + +// PrivateCloud a private cloud resource +type PrivateCloud struct { + autorest.Response `json:"-"` + // Sku - The private cloud SKU + Sku *Sku `json:"sku,omitempty"` + // PrivateCloudProperties - The properties of a private cloud resource + *PrivateCloudProperties `json:"properties,omitempty"` + // Location - Resource location + Location *string `json:"location,omitempty"` + // Tags - Resource tags + Tags map[string]*string `json:"tags"` + // 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"` +} + +// MarshalJSON is the custom marshaler for PrivateCloud. +func (pc PrivateCloud) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if pc.Sku != nil { + objectMap["sku"] = pc.Sku + } + if pc.PrivateCloudProperties != nil { + objectMap["properties"] = pc.PrivateCloudProperties + } + if pc.Location != nil { + objectMap["location"] = pc.Location + } + if pc.Tags != nil { + objectMap["tags"] = pc.Tags + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for PrivateCloud struct. +func (pc *PrivateCloud) 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 + } + pc.Sku = &sku + } + case "properties": + if v != nil { + var privateCloudProperties PrivateCloudProperties + err = json.Unmarshal(*v, &privateCloudProperties) + if err != nil { + return err + } + pc.PrivateCloudProperties = &privateCloudProperties + } + case "location": + if v != nil { + var location string + err = json.Unmarshal(*v, &location) + if err != nil { + return err + } + pc.Location = &location + } + case "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + pc.Tags = tags + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + pc.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + pc.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + pc.Type = &typeVar + } + } + } + + return nil +} + +// PrivateCloudList a paged list of private clouds +type PrivateCloudList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on the page + Value *[]PrivateCloud `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// PrivateCloudListIterator provides access to a complete listing of PrivateCloud values. +type PrivateCloudListIterator struct { + i int + page PrivateCloudListPage +} + +// 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 *PrivateCloudListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudListIterator.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 *PrivateCloudListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter PrivateCloudListIterator) 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 PrivateCloudListIterator) Response() PrivateCloudList { + 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 PrivateCloudListIterator) Value() PrivateCloud { + if !iter.page.NotDone() { + return PrivateCloud{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the PrivateCloudListIterator type. +func NewPrivateCloudListIterator(page PrivateCloudListPage) PrivateCloudListIterator { + return PrivateCloudListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (pcl PrivateCloudList) IsEmpty() bool { + return pcl.Value == nil || len(*pcl.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (pcl PrivateCloudList) hasNextLink() bool { + return pcl.NextLink != nil && len(*pcl.NextLink) != 0 +} + +// privateCloudListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (pcl PrivateCloudList) privateCloudListPreparer(ctx context.Context) (*http.Request, error) { + if !pcl.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(pcl.NextLink))) +} + +// PrivateCloudListPage contains a page of PrivateCloud values. +type PrivateCloudListPage struct { + fn func(context.Context, PrivateCloudList) (PrivateCloudList, error) + pcl PrivateCloudList +} + +// 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 *PrivateCloudListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudListPage.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.pcl) + if err != nil { + return err + } + page.pcl = 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 *PrivateCloudListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page PrivateCloudListPage) NotDone() bool { + return !page.pcl.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page PrivateCloudListPage) Response() PrivateCloudList { + return page.pcl +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page PrivateCloudListPage) Values() []PrivateCloud { + if page.pcl.IsEmpty() { + return nil + } + return *page.pcl.Value +} + +// Creates a new instance of the PrivateCloudListPage type. +func NewPrivateCloudListPage(getNextPage func(context.Context, PrivateCloudList) (PrivateCloudList, error)) PrivateCloudListPage { + return PrivateCloudListPage{fn: getNextPage} +} + +// PrivateCloudProperties the properties of a private cloud resource +type PrivateCloudProperties struct { + // ProvisioningState - READ-ONLY; The provisioning state. Possible values include: 'PrivateCloudProvisioningStateSucceeded', 'PrivateCloudProvisioningStateFailed', 'PrivateCloudProvisioningStateCancelled', 'PrivateCloudProvisioningStatePending', 'PrivateCloudProvisioningStateBuilding', 'PrivateCloudProvisioningStateDeleting', 'PrivateCloudProvisioningStateUpdating' + ProvisioningState PrivateCloudProvisioningState `json:"provisioningState,omitempty"` + // Circuit - An ExpressRoute Circuit + Circuit *Circuit `json:"circuit,omitempty"` + // Endpoints - READ-ONLY; The endpoints + Endpoints *Endpoints `json:"endpoints,omitempty"` + // NetworkBlock - The block of addresses should be unique across VNet in your subscription as well as on-premise. Make sure the CIDR format is conformed to (A.B.C.D/X) where A,B,C,D are between 0 and 255, and X is between 0 and 22 + NetworkBlock *string `json:"networkBlock,omitempty"` + // ManagementNetwork - READ-ONLY; Network used to access vCenter Server and NSX-T Manager + ManagementNetwork *string `json:"managementNetwork,omitempty"` + // ProvisioningNetwork - READ-ONLY; Used for virtual machine cold migration, cloning, and snapshot migration + ProvisioningNetwork *string `json:"provisioningNetwork,omitempty"` + // VmotionNetwork - READ-ONLY; Used for live migration of virtual machines + VmotionNetwork *string `json:"vmotionNetwork,omitempty"` + // VcenterPassword - Optionally, set the vCenter admin password when the private cloud is created + VcenterPassword *string `json:"vcenterPassword,omitempty"` + // NsxtPassword - Optionally, set the NSX-T Manager password when the private cloud is created + NsxtPassword *string `json:"nsxtPassword,omitempty"` + // VcenterCertificateThumbprint - READ-ONLY; Thumbprint of the vCenter Server SSL certificate + VcenterCertificateThumbprint *string `json:"vcenterCertificateThumbprint,omitempty"` + // NsxtCertificateThumbprint - READ-ONLY; Thumbprint of the NSX-T Manager SSL certificate + NsxtCertificateThumbprint *string `json:"nsxtCertificateThumbprint,omitempty"` + // ManagementCluster - The default cluster used for management + ManagementCluster *ManagementCluster `json:"managementCluster,omitempty"` + // Internet - Connectivity to internet is enabled or disabled. Possible values include: 'Enabled', 'Disabled' + Internet InternetEnum `json:"internet,omitempty"` + // IdentitySources - vCenter Single Sign On Identity Sources + IdentitySources *[]IdentitySource `json:"identitySources,omitempty"` +} + +// MarshalJSON is the custom marshaler for PrivateCloudProperties. +func (pcp PrivateCloudProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if pcp.Circuit != nil { + objectMap["circuit"] = pcp.Circuit + } + if pcp.NetworkBlock != nil { + objectMap["networkBlock"] = pcp.NetworkBlock + } + if pcp.VcenterPassword != nil { + objectMap["vcenterPassword"] = pcp.VcenterPassword + } + if pcp.NsxtPassword != nil { + objectMap["nsxtPassword"] = pcp.NsxtPassword + } + if pcp.ManagementCluster != nil { + objectMap["managementCluster"] = pcp.ManagementCluster + } + if pcp.Internet != "" { + objectMap["internet"] = pcp.Internet + } + if pcp.IdentitySources != nil { + objectMap["identitySources"] = pcp.IdentitySources + } + return json.Marshal(objectMap) +} + +// PrivateCloudsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type PrivateCloudsCreateOrUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *PrivateCloudsCreateOrUpdateFuture) Result(client PrivateCloudsClient) (pc PrivateCloud, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if pc.Response.Response, err = future.GetResult(sender); err == nil && pc.Response.Response.StatusCode != http.StatusNoContent { + pc, err = client.CreateOrUpdateResponder(pc.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsCreateOrUpdateFuture", "Result", pc.Response.Response, "Failure responding to request") + } + } + return +} + +// PrivateCloudsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type PrivateCloudsDeleteFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *PrivateCloudsDeleteFuture) Result(client PrivateCloudsClient) (ar autorest.Response, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsDeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsDeleteFuture") + return + } + ar.Response = future.Response() + return +} + +// PrivateCloudsUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type PrivateCloudsUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *PrivateCloudsUpdateFuture) Result(client PrivateCloudsClient) (pc PrivateCloud, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if pc.Response.Response, err = future.GetResult(sender); err == nil && pc.Response.Response.StatusCode != http.StatusNoContent { + pc, err = client.UpdateResponder(pc.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsUpdateFuture", "Result", pc.Response.Response, "Failure responding to request") + } + } + return +} + +// PrivateCloudUpdate an update to a private cloud resource +type PrivateCloudUpdate struct { + // Tags - Resource tags. + Tags map[string]*string `json:"tags"` + // PrivateCloudUpdateProperties - The updatable properties of a private cloud resource + *PrivateCloudUpdateProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for PrivateCloudUpdate. +func (pcu PrivateCloudUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if pcu.Tags != nil { + objectMap["tags"] = pcu.Tags + } + if pcu.PrivateCloudUpdateProperties != nil { + objectMap["properties"] = pcu.PrivateCloudUpdateProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for PrivateCloudUpdate struct. +func (pcu *PrivateCloudUpdate) 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 "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + pcu.Tags = tags + } + case "properties": + if v != nil { + var privateCloudUpdateProperties PrivateCloudUpdateProperties + err = json.Unmarshal(*v, &privateCloudUpdateProperties) + if err != nil { + return err + } + pcu.PrivateCloudUpdateProperties = &privateCloudUpdateProperties + } + } + } + + return nil +} + +// PrivateCloudUpdateProperties the properties of a private cloud resource that may be updated +type PrivateCloudUpdateProperties struct { + // ManagementCluster - The default cluster used for management + ManagementCluster *ManagementCluster `json:"managementCluster,omitempty"` + // Internet - Connectivity to internet is enabled or disabled. Possible values include: 'Enabled', 'Disabled' + Internet InternetEnum `json:"internet,omitempty"` + // IdentitySources - vCenter Single Sign On Identity Sources + IdentitySources *[]IdentitySource `json:"identitySources,omitempty"` +} + +// Quota subscription quotas +type Quota struct { + autorest.Response `json:"-"` + // HostsRemaining - READ-ONLY; Remaining hosts quota by sku type + HostsRemaining map[string]*int32 `json:"hostsRemaining"` + // QuotaEnabled - READ-ONLY; Host quota is active for current subscription. Possible values include: 'QuotaEnabledEnabled', 'QuotaEnabledDisabled' + QuotaEnabled QuotaEnabled `json:"quotaEnabled,omitempty"` +} + +// MarshalJSON is the custom marshaler for Quota. +func (q Quota) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// Resource the core properties of ARM resources +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"` +} + +// Sku the resource model definition representing SKU +type Sku struct { + // Name - The name of the SKU. + Name *string `json:"name,omitempty"` +} + +// TrackedResource the resource model definition for a ARM tracked top level resource +type TrackedResource struct { + // Location - Resource location + Location *string `json:"location,omitempty"` + // Tags - Resource tags + Tags map[string]*string `json:"tags"` + // 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"` +} + +// MarshalJSON is the custom marshaler for TrackedResource. +func (tr TrackedResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if tr.Location != nil { + objectMap["location"] = tr.Location + } + if tr.Tags != nil { + objectMap["tags"] = tr.Tags + } + return json.Marshal(objectMap) +} + +// Trial subscription trial availability +type Trial struct { + autorest.Response `json:"-"` + // Status - READ-ONLY; Trial status. Possible values include: 'TrialAvailable', 'TrialUsed', 'TrialDisabled' + Status TrialStatus `json:"status,omitempty"` + // AvailableHosts - READ-ONLY; Number of trial hosts available + AvailableHosts *int32 `json:"availableHosts,omitempty"` +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go new file mode 100644 index 000000000000..765297556ad5 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go @@ -0,0 +1,149 @@ +package avs + +// 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 azure VMware Solution 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 operations +func (client OperationsClient) List(ctx context.Context) (result OperationListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List") + defer func() { + sc := -1 + if result.ol.Response.Response != nil { + sc = result.ol.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.ol.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", resp, "Failure sending request") + return + } + + result.ol, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", resp, "Failure responding to request") + } + if result.ol.hasNextLink() && result.ol.IsEmpty() { + err = result.NextWithContext(ctx) + } + + return +} + +// ListPreparer prepares the List request. +func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) { + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.AVS/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 OperationList, 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 OperationList) (result OperationList, err error) { + req, err := lastResults.operationListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.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, "avs.OperationsClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.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 OperationListIterator, 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/avs/mgmt/2020-03-20/avs/privateclouds.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/privateclouds.go new file mode 100644 index 000000000000..82af8e23b5ba --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/privateclouds.go @@ -0,0 +1,719 @@ +package avs + +// 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" +) + +// PrivateCloudsClient is the azure VMware Solution API +type PrivateCloudsClient struct { + BaseClient +} + +// NewPrivateCloudsClient creates an instance of the PrivateCloudsClient client. +func NewPrivateCloudsClient(subscriptionID string) PrivateCloudsClient { + return NewPrivateCloudsClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewPrivateCloudsClientWithBaseURI creates an instance of the PrivateCloudsClient 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 NewPrivateCloudsClientWithBaseURI(baseURI string, subscriptionID string) PrivateCloudsClient { + return PrivateCloudsClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// privateCloud - the private cloud +func (client PrivateCloudsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud PrivateCloud) (result PrivateCloudsCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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: privateCloud, + Constraints: []validation.Constraint{{Target: "privateCloud.Sku", Name: validation.Null, Rule: true, + Chain: []validation.Constraint{{Target: "privateCloud.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}, + {Target: "privateCloud.PrivateCloudProperties", Name: validation.Null, Rule: true, + Chain: []validation.Constraint{{Target: "privateCloud.PrivateCloudProperties.NetworkBlock", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { + return result, validation.NewError("avs.PrivateCloudsClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, privateCloud) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client PrivateCloudsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud PrivateCloud) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}", pathParameters), + autorest.WithJSON(privateCloud), + 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 PrivateCloudsClient) CreateOrUpdateSender(req *http.Request) (future PrivateCloudsCreateOrUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) CreateOrUpdateResponder(resp *http.Response) (result PrivateCloud, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client PrivateCloudsClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string) (result PrivateCloudsDeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client PrivateCloudsClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}", 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 PrivateCloudsClient) DeleteSender(req *http.Request) (future PrivateCloudsDeleteFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) 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 sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client PrivateCloudsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string) (result PrivateCloud, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client PrivateCloudsClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}", 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 PrivateCloudsClient) 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 PrivateCloudsClient) GetResponder(resp *http.Response) (result PrivateCloud, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +func (client PrivateCloudsClient) List(ctx context.Context, resourceGroupName string) (result PrivateCloudListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.List") + defer func() { + sc := -1 + if result.pcl.Response.Response != nil { + sc = result.pcl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.pcl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", resp, "Failure sending request") + return + } + + result.pcl, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", resp, "Failure responding to request") + } + if result.pcl.hasNextLink() && result.pcl.IsEmpty() { + err = result.NextWithContext(ctx) + } + + return +} + +// ListPreparer prepares the List request. +func (client PrivateCloudsClient) 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 = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds", 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 PrivateCloudsClient) 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 PrivateCloudsClient) ListResponder(resp *http.Response) (result PrivateCloudList, 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 PrivateCloudsClient) listNextResults(ctx context.Context, lastResults PrivateCloudList) (result PrivateCloudList, err error) { + req, err := lastResults.privateCloudListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "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, "avs.PrivateCloudsClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client PrivateCloudsClient) ListComplete(ctx context.Context, resourceGroupName string) (result PrivateCloudListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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 +} + +// ListAdminCredentials sends the list admin credentials request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client PrivateCloudsClient) ListAdminCredentials(ctx context.Context, resourceGroupName string, privateCloudName string) (result AdminCredentials, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListAdminCredentials") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "ListAdminCredentials", err.Error()) + } + + req, err := client.ListAdminCredentialsPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", nil, "Failure preparing request") + return + } + + resp, err := client.ListAdminCredentialsSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", resp, "Failure sending request") + return + } + + result, err = client.ListAdminCredentialsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", resp, "Failure responding to request") + } + + return +} + +// ListAdminCredentialsPreparer prepares the ListAdminCredentials request. +func (client PrivateCloudsClient) ListAdminCredentialsPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/listAdminCredentials", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListAdminCredentialsSender sends the ListAdminCredentials request. The method will close the +// http.Response Body if it receives an error. +func (client PrivateCloudsClient) ListAdminCredentialsSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListAdminCredentialsResponder handles the response to the ListAdminCredentials request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) ListAdminCredentialsResponder(resp *http.Response) (result AdminCredentials, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListInSubscription sends the list in subscription request. +func (client PrivateCloudsClient) ListInSubscription(ctx context.Context) (result PrivateCloudListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListInSubscription") + defer func() { + sc := -1 + if result.pcl.Response.Response != nil { + sc = result.pcl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.PrivateCloudsClient", "ListInSubscription", err.Error()) + } + + result.fn = client.listInSubscriptionNextResults + req, err := client.ListInSubscriptionPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", nil, "Failure preparing request") + return + } + + resp, err := client.ListInSubscriptionSender(req) + if err != nil { + result.pcl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", resp, "Failure sending request") + return + } + + result.pcl, err = client.ListInSubscriptionResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", resp, "Failure responding to request") + } + if result.pcl.hasNextLink() && result.pcl.IsEmpty() { + err = result.NextWithContext(ctx) + } + + return +} + +// ListInSubscriptionPreparer prepares the ListInSubscription request. +func (client PrivateCloudsClient) ListInSubscriptionPreparer(ctx context.Context) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/privateClouds", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListInSubscriptionSender sends the ListInSubscription request. The method will close the +// http.Response Body if it receives an error. +func (client PrivateCloudsClient) ListInSubscriptionSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListInSubscriptionResponder handles the response to the ListInSubscription request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) ListInSubscriptionResponder(resp *http.Response) (result PrivateCloudList, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listInSubscriptionNextResults retrieves the next set of results, if any. +func (client PrivateCloudsClient) listInSubscriptionNextResults(ctx context.Context, lastResults PrivateCloudList) (result PrivateCloudList, err error) { + req, err := lastResults.privateCloudListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListInSubscriptionSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", resp, "Failure sending next results request") + } + result, err = client.ListInSubscriptionResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListInSubscriptionComplete enumerates all values, automatically crossing page boundaries as required. +func (client PrivateCloudsClient) ListInSubscriptionComplete(ctx context.Context) (result PrivateCloudListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListInSubscription") + 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.ListInSubscription(ctx) + return +} + +// Update sends the update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// privateCloudUpdate - the private cloud properties to be updated +func (client PrivateCloudsClient) Update(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate PrivateCloudUpdate) (result PrivateCloudsUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "Update", err.Error()) + } + + req, err := client.UpdatePreparer(ctx, resourceGroupName, privateCloudName, privateCloudUpdate) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Update", nil, "Failure preparing request") + return + } + + result, err = client.UpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Update", result.Response(), "Failure sending request") + return + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client PrivateCloudsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate PrivateCloudUpdate) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}", pathParameters), + autorest.WithJSON(privateCloudUpdate), + 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 PrivateCloudsClient) UpdateSender(req *http.Request) (future PrivateCloudsUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) UpdateResponder(resp *http.Response) (result PrivateCloud, 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/avs/mgmt/2020-03-20/avs/version.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/version.go new file mode 100644 index 000000000000..23307592c097 --- /dev/null +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/version.go @@ -0,0 +1,30 @@ +package avs + +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() + " avs/2020-03-20" +} + +// Version returns the semantic version (see http://semver.org) of the client. +func Version() string { + return version.Number +} From b2fcebd3b20e408d91e234491a03f5d1f3094fa1 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Wed, 12 Aug 2020 14:33:37 +0800 Subject: [PATCH 02/23] update --- azurerm/internal/provider/services.go | 2 + .../avs/avs_private_clouds_data_source.go | 95 +- .../avs/avs_private_clouds_resource.go | 1142 +++--- .../internal/services/avs/client/client.go | 32 +- .../services/avs/parse/avs_authorizations.go | 32 - .../avs/parse/avs_authorizations_test.go | 77 - .../services/avs/parse/avs_clusters.go | 33 - .../services/avs/parse/avs_clusters_test.go | 77 - .../avs/parse/avs_hcx_enterprise_sites.go | 33 - .../parse/avs_hcx_enterprise_sites_test.go | 77 - .../services/avs/parse/avs_private_clouds.go | 37 +- .../avs/parse/avs_private_clouds_test.go | 122 +- azurerm/internal/services/avs/registration.go | 26 +- .../avs_private_clouds_data_source_test.go | 41 +- .../tests/avs_private_clouds_resource_test.go | 592 +-- .../avs/mgmt/2020-03-20/avs/authorizations.go | 861 ++-- .../mgmt/2020-03-20/avs/avsapi/interfaces.go | 89 - .../avs/mgmt/2020-03-20/avs/client.go | 104 +- .../avs/mgmt/2020-03-20/avs/clusters.go | 1049 +++-- .../mgmt/2020-03-20/avs/hcxenterprisesites.go | 863 ++-- .../avs/mgmt/2020-03-20/avs/locations.go | 402 +- .../avs/mgmt/2020-03-20/avs/models.go | 3592 +++++++++-------- .../avs/mgmt/2020-03-20/avs/operations.go | 295 +- .../avs/mgmt/2020-03-20/avs/privateclouds.go | 1432 ++++--- .../avs/mgmt/2020-03-20/avs/version.go | 60 +- .../autorest/azure/environments.go | 8 +- vendor/modules.txt | 1 + 27 files changed, 5410 insertions(+), 5764 deletions(-) delete mode 100644 azurerm/internal/services/avs/parse/avs_authorizations.go delete mode 100644 azurerm/internal/services/avs/parse/avs_authorizations_test.go delete mode 100644 azurerm/internal/services/avs/parse/avs_clusters.go delete mode 100644 azurerm/internal/services/avs/parse/avs_clusters_test.go delete mode 100644 azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go delete mode 100644 azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go delete mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go diff --git a/azurerm/internal/provider/services.go b/azurerm/internal/provider/services.go index 49a3b4c9946f..278a8b64f3d4 100644 --- a/azurerm/internal/provider/services.go +++ b/azurerm/internal/provider/services.go @@ -9,6 +9,7 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/appplatform" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/authorization" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/automation" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/batch" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/blueprints" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/bot" @@ -92,6 +93,7 @@ func SupportedServices() []common.ServiceRegistration { applicationinsights.Registration{}, authorization.Registration{}, automation.Registration{}, + avs.Registration{}, batch.Registration{}, blueprints.Registration{}, bot.Registration{}, diff --git a/azurerm/internal/services/avs/avs_private_clouds_data_source.go b/azurerm/internal/services/avs/avs_private_clouds_data_source.go index f17087e87cf8..dc374d2c247e 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_data_source.go +++ b/azurerm/internal/services/avs/avs_private_clouds_data_source.go @@ -1,61 +1,62 @@ package avs import ( - "fmt" - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" - "time" + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "time" ) + func dataSourceAvsPrivateCloud() *schema.Resource { - return &schema.Resource{ - Read: dataSourceArmAvsPrivateCloudRead, + return &schema.Resource{ + Read: dataSourceArmAvsPrivateCloudRead, - Timeouts: &schema.ResourceTimeout{ - Read: schema.DefaultTimeout(5 * time.Minute), - }, + Timeouts: &schema.ResourceTimeout{ + Read: schema.DefaultTimeout(5 * time.Minute), + }, - Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Required: true, - }, + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + }, - "resource_group_name": azure.SchemaResourceGroupNameForDataSource(), + "resource_group_name": azure.SchemaResourceGroupNameForDataSource(), - "location": azure.SchemaLocationForDataSource(), + "location": azure.SchemaLocationForDataSource(), - "tags": tags.SchemaDataSource(), - }, - } + "tags": tags.SchemaDataSource(), + }, + } } func dataSourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) error { - client := meta.(*clients.Client).Avs.PrivateCloudClient - ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) - defer cancel() - - name := d.Get("name").(string) - resourceGroup := d.Get("resource_group_name").(string) - - resp, err :=client.Get(ctx, resourceGroup, name) - if err != nil { - if utils.ResponseWasNotFound(resp.Response) { - return fmt.Errorf("Avs PrivateCloud %q does not exist", name) - } - return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) - } - if resp.ID == nil || *resp.ID== "" { - return fmt.Errorf("empty or nil ID returned for Avs PrivateCloud %q (Resource Group %q) ID", name, resourceGroup) - } - - d.SetId(*resp.ID) - d.Set("name", name) - d.Set("resource_group_name", resourceGroup) - d.Set("location", location.NormalizeNilable(resp.Location)) - return tags.FlattenAndSet(d, resp.Tags) + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) + defer cancel() + + name := d.Get("name").(string) + resourceGroup := d.Get("resource_group_name").(string) + + resp, err := client.Get(ctx, resourceGroup, name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("Avs PrivateCloud %q does not exist", name) + } + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + if resp.ID == nil || *resp.ID == "" { + return fmt.Errorf("empty or nil ID returned for Avs PrivateCloud %q (Resource Group %q) ID", name, resourceGroup) + } + + d.SetId(*resp.ID) + d.Set("name", name) + d.Set("resource_group_name", resourceGroup) + d.Set("location", location.NormalizeNilable(resp.Location)) + return tags.FlattenAndSet(d, resp.Tags) } diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index a8fa54c1bf00..42e97f9cfeae 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -1,630 +1,570 @@ package avs import ( - "fmt" - "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags" - azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" - "log" - "time" + "fmt" + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/helper/validation" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/suppress" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags" + azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "log" + "time" ) + func resourceArmAvsPrivateCloud() *schema.Resource { - return &schema.Resource{ - Create: resourceArmAvsPrivateCloudCreate, - Read: resourceArmAvsPrivateCloudRead, - Update: resourceArmAvsPrivateCloudUpdate, - Delete: resourceArmAvsPrivateCloudDelete, - - Timeouts: &schema.ResourceTimeout{ - Create: schema.DefaultTimeout(30 * time.Minute), - Read: schema.DefaultTimeout(5 * time.Minute), - Update: schema.DefaultTimeout(30 * time.Minute), - Delete: schema.DefaultTimeout(30 * time.Minute), - }, - - Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { - _, err := parse.AvsPrivateCloudID(id) - return err - }), - - - Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - }, - - "resource_group_name": azure.SchemaResourceGroupName(), - - "location": azure.SchemaLocation(), - - "sku": { - Type: schema.TypeList, - Required: true, - ForceNew: true, - MaxItems: 1, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - }, - }, - }, - }, - - "management_cluster": { - Type: schema.TypeList, - Required: true, - MaxItems: 1, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "cluster_size": { - Type: schema.TypeInt, - Required: true, - }, - - "cluster_id": { - Type: schema.TypeInt, - Computed: true, - }, - - "hosts": { - Type: schema.TypeSet, - Computed: true, - Elem: &schema.Schema{ - Type: schema.TypeString, - }, - }, - }, - }, - }, - - "network_block": { - Type: schema.TypeString, - Required: true, - }, - - "circuit": { - Type: schema.TypeList, - Computed: true, - MaxItems: 1, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "express_route_id": { - Type: schema.TypeString, - Computed: true, - }, - - "express_route_private_peering_id": { - Type: schema.TypeString, - Computed: true, - }, - - "primary_subnet": { - Type: schema.TypeString, - Computed: true, - }, - - "secondary_subnet": { - Type: schema.TypeString, - Computed: true, - }, - }, - }, - }, - - "identity_source": { - Type: schema.TypeSet, - Optional: true, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Optional: true, - }, - - "alias": { - Type: schema.TypeString, - Optional: true, - }, - - "base_group_dn": { - Type: schema.TypeString, - Optional: true, - }, - - "base_user_dn": { - Type: schema.TypeString, - Optional: true, - }, - - "domain": { - Type: schema.TypeString, - Optional: true, - }, - - "password": { - Type: schema.TypeString, - Optional: true, - }, - - "primary_server": { - Type: schema.TypeString, - Optional: true, - }, - - "secondary_server": { - Type: schema.TypeString, - Optional: true, - }, - - "ssl": { - Type: schema.TypeBool, - Optional: true, - }, - - "username": { - Type: schema.TypeString, - Optional: true, - }, - }, - }, - }, - - "internet": { - Type: schema.TypeBool, - Optional: true, - }, - - "nsxt_password": { - Type: schema.TypeString, - Optional: true, - }, - - "vcenter_password": { - Type: schema.TypeString, - Optional: true, - }, - - "endpoint": { - Type: schema.TypeList, - Computed: true, - MaxItems: 1, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "hcx_cloud_manager": { - Type: schema.TypeString, - Computed: true, - }, - - "nsxt_manager": { - Type: schema.TypeString, - Computed: true, - }, - - "vcsa": { - Type: schema.TypeString, - Computed: true, - }, - }, - }, - }, - - "management_network": { - Type: schema.TypeString, - Computed: true, - }, - - "nsxt_certificate_thumbprint": { - Type: schema.TypeString, - Computed: true, - }, - - "provisioning_network": { - Type: schema.TypeString, - Computed: true, - }, - - "type": { - Type: schema.TypeString, - Computed: true, - }, - - "vcenter_certificate_thumbprint": { - Type: schema.TypeString, - Computed: true, - }, - - "vmotion_network": { - Type: schema.TypeString, - Computed: true, - }, - - "tags": tags.Schema(), - }, - } + return &schema.Resource{ + Create: resourceArmAvsPrivateCloudCreate, + Read: resourceArmAvsPrivateCloudRead, + Update: resourceArmAvsPrivateCloudUpdate, + Delete: resourceArmAvsPrivateCloudDelete, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(30 * time.Minute), + Read: schema.DefaultTimeout(5 * time.Minute), + Update: schema.DefaultTimeout(30 * time.Minute), + Delete: schema.DefaultTimeout(30 * time.Minute), + }, + + Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { + _, err := parse.AvsPrivateCloudID(id) + return err + }), + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "resource_group_name": azure.SchemaResourceGroupName(), + + "location": azure.SchemaLocation(), + + "sku_name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{ + "av20", + "av36", + "av36t", + }, true), + DiffSuppressFunc: suppress.CaseDifference, + }, + + "management_cluster": { + Type: schema.TypeList, + Required: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "cluster_size": { + Type: schema.TypeInt, + Required: true, + ValidateFunc: validation.IntBetween(3, 16), + }, + + "cluster_id": { + Type: schema.TypeInt, + Computed: true, + }, + + "hosts": { + Type: schema.TypeSet, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + }, + }, + + "network_block": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.IsCIDR, + }, + + "identity_source": { + Type: schema.TypeSet, + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "alias": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "base_group_dn": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "base_user_dn": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "domain": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "password": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "primary_server_url": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.IsURLWithHTTPorHTTPS, + }, + + "secondary_server_url": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.IsURLWithHTTPorHTTPS, + }, + + "ssl_enabled": { + Type: schema.TypeBool, + Required: true, + }, + + "username": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + }, + }, + }, + + "internet_connected": { + Type: schema.TypeBool, + Optional: true, + Default: false, + }, + + "nsxt_password": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "vcenter_password": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + ValidateFunc: validation.StringIsNotEmpty, + }, + + "circuit": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "express_route_id": { + Type: schema.TypeString, + Computed: true, + }, + + "express_route_private_peering_id": { + Type: schema.TypeString, + Computed: true, + }, + + "primary_subnet": { + Type: schema.TypeString, + Computed: true, + }, + + "secondary_subnet": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + + "hcx_cloud_manager_endpoint": { + Type: schema.TypeString, + Computed: true, + }, + + "management_network": { + Type: schema.TypeString, + Computed: true, + }, + + "nsxt_certificate_thumbprint": { + Type: schema.TypeString, + Computed: true, + }, + + "nsxt_manager_endpoint": { + Type: schema.TypeString, + Computed: true, + }, + + "provisioning_network": { + Type: schema.TypeString, + Computed: true, + }, + + "vcenter_certificate_thumbprint": { + Type: schema.TypeString, + Computed: true, + }, + + "vcsa_endpoint": { + Type: schema.TypeString, + Computed: true, + }, + + "vmotion_network": { + Type: schema.TypeString, + Computed: true, + }, + + "tags": tags.Schema(), + }, + } } func resourceArmAvsPrivateCloudCreate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*clients.Client).Avs.PrivateCloudClient - ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) - defer cancel() - - name := d.Get("name").(string) - resourceGroup := d.Get("resource_group_name").(string) - - existing, err :=client.Get(ctx, resourceGroup, name) - if err != nil { - if !utils.ResponseWasNotFound(existing.Response) { - return fmt.Errorf("checking for present of existing Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) - } - } - if existing.ID != nil && *existing.ID != "" { - return tf.ImportAsExistsError("azurerm_avs_private_cloud", *existing.ID) - } - - internet := avs.Disabled - if d.Get("internet").(bool) { - internet = avs.Enabled - } - - privateCloud := avs.PrivateCloud{ - Location: utils.String(location.Normalize(d.Get("location").(string))), - Sku: expandArmPrivateCloudSku(d.Get("sku").([]interface{})), - PrivateCloudProperties: &avs.PrivateCloudProperties{ - ManagementCluster: expandArmPrivateCloudManagementCluster(d.Get("management_cluster").([]interface{})), - NetworkBlock: utils.String(d.Get("network_block").(string)), - IdentitySources: expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()), - Internet: internet, - NsxtPassword: utils.String(d.Get("nsxt_password").(string)), - VcenterPassword: utils.String(d.Get("vcenter_password").(string)), - }, - Tags: tags.Expand(d.Get("tags").(map[string]interface{})), - } - future, err :=client.CreateOrUpdate(ctx, resourceGroup, name, privateCloud) - if err != nil { - return fmt.Errorf("creating Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) - } - - if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { - return fmt.Errorf("waiting on creating future for Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) - } - - resp, err :=client.Get(ctx, resourceGroup, name) - if err != nil { - return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) - } - - if resp.ID == nil || *resp.ID== "" { - return fmt.Errorf("empty or nil ID returned for Avs PrivateCloud %q (Resource Group %q) ID", name, resourceGroup) - } - - d.SetId(*resp.ID) - return resourceArmAvsPrivateCloudRead(d, meta) + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) + defer cancel() + + name := d.Get("name").(string) + resourceGroup := d.Get("resource_group_name").(string) + + existing, err := client.Get(ctx, resourceGroup, name) + if err != nil { + if !utils.ResponseWasNotFound(existing.Response) { + return fmt.Errorf("checking for present of existing Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + } + if existing.ID != nil && *existing.ID != "" { + return tf.ImportAsExistsError("azurerm_avs_private_cloud", *existing.ID) + } + + internet := avs.Disabled + if d.Get("internet_connected").(bool) { + internet = avs.Enabled + } + + privateCloud := avs.PrivateCloud{ + Location: utils.String(location.Normalize(d.Get("location").(string))), + Sku: &avs.Sku{ + Name: utils.String(d.Get("sku_name").(string)), + }, + PrivateCloudProperties: &avs.PrivateCloudProperties{ + ManagementCluster: &avs.ManagementCluster{ + ClusterSize: utils.Int32(int32(d.Get("management_cluster.0.cluster_size").(int))), + }, + NetworkBlock: utils.String(d.Get("network_block").(string)), + IdentitySources: expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()), + Internet: internet, + NsxtPassword: utils.String(d.Get("nsxt_password").(string)), + VcenterPassword: utils.String(d.Get("vcenter_password").(string)), + }, + Tags: tags.Expand(d.Get("tags").(map[string]interface{})), + } + future, err := client.CreateOrUpdate(ctx, resourceGroup, name, privateCloud) + if err != nil { + return fmt.Errorf("creating Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on creating future for Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + + resp, err := client.Get(ctx, resourceGroup, name) + if err != nil { + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", name, resourceGroup, err) + } + + if resp.ID == nil || *resp.ID == "" { + return fmt.Errorf("empty or nil ID returned for Avs PrivateCloud %q (Resource Group %q) ID", name, resourceGroup) + } + + d.SetId(*resp.ID) + return resourceArmAvsPrivateCloudRead(d, meta) } func resourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) error { - client := meta.(*clients.Client).Avs.PrivateCloudClient - ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) - defer cancel() - - id, err := parse.AvsPrivateCloudID(d.Id()) - if err != nil { - return err - } - - resp, err :=client.Get(ctx, id.ResourceGroup, id.Name) - if err != nil { - if utils.ResponseWasNotFound(resp.Response) { - log.Printf("[INFO] avs %q does not exist - removing from state", d.Id()) - d.SetId("") - return nil - } - return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) - } - d.Set("name", id.Name) - d.Set("resource_group_name", id.ResourceGroup) - d.Set("location", location.NormalizeNilable(resp.Location)) - if props := resp.PrivateCloudProperties; props != nil { - if err := d.Set("management_cluster", flattenArmPrivateCloudManagementCluster(props.ManagementCluster)); err != nil { - return fmt.Errorf("setting `management_cluster`: %+v", err) - } - d.Set("network_block", props.NetworkBlock) - if err := d.Set("circuit", flattenArmPrivateCloudCircuit(props.Circuit)); err != nil { - return fmt.Errorf("setting `circuit`: %+v", err) - } - if err := d.Set("identity_source", flattenArmPrivateCloudIdentitySourceArray(props.IdentitySources)); err != nil { - return fmt.Errorf("setting `identity_source`: %+v", err) - } - d.Set("internet", props.Internet==avs.Enabled) - d.Set("nsxt_password", props.NsxtPassword) - d.Set("vcenter_password", props.VcenterPassword) - if err := d.Set("endpoint", flattenArmPrivateCloudEndpoints(props.Endpoints)); err != nil { - return fmt.Errorf("setting `endpoint`: %+v", err) - } - d.Set("management_network", props.ManagementNetwork) - d.Set("nsxt_certificate_thumbprint", props.NsxtCertificateThumbprint) - d.Set("provisioning_network", props.ProvisioningNetwork) - d.Set("vcenter_certificate_thumbprint", props.VcenterCertificateThumbprint) - d.Set("vmotion_network", props.VmotionNetwork) - } - if err := d.Set("sku", flattenArmPrivateCloudSku(resp.Sku)); err != nil { - return fmt.Errorf("setting `sku`: %+v", err) - } - d.Set("type", resp.Type) - return tags.FlattenAndSet(d, resp.Tags) + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsPrivateCloudID(d.Id()) + if err != nil { + return err + } + + resp, err := client.Get(ctx, id.ResourceGroup, id.Name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + log.Printf("[INFO] avs %q does not exist - removing from state", d.Id()) + d.SetId("") + return nil + } + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + d.Set("name", id.Name) + d.Set("resource_group_name", id.ResourceGroup) + d.Set("location", location.NormalizeNilable(resp.Location)) + if props := resp.PrivateCloudProperties; props != nil { + if err := d.Set("management_cluster", flattenArmPrivateCloudManagementCluster(props.ManagementCluster)); err != nil { + return fmt.Errorf("setting `management_cluster`: %+v", err) + } + d.Set("network_block", props.NetworkBlock) + if err := d.Set("circuit", flattenArmPrivateCloudCircuit(props.Circuit)); err != nil { + return fmt.Errorf("setting `circuit`: %+v", err) + } + if err := d.Set("identity_source", flattenArmPrivateCloudIdentitySourceArray(props.IdentitySources)); err != nil { + return fmt.Errorf("setting `identity_source`: %+v", err) + } + d.Set("internet_connected", props.Internet == avs.Enabled) + d.Set("nsxt_password", props.NsxtPassword) + d.Set("vcenter_password", props.VcenterPassword) + d.Set("hcx_cloud_manager_endpoint", props.Endpoints.HcxCloudManager) + d.Set("nsxt_manager_endpoint", props.Endpoints.NsxtManager) + d.Set("vcsa_endpoint", props.Endpoints.Vcsa) + d.Set("management_network", props.ManagementNetwork) + d.Set("nsxt_certificate_thumbprint", props.NsxtCertificateThumbprint) + d.Set("provisioning_network", props.ProvisioningNetwork) + d.Set("vcenter_certificate_thumbprint", props.VcenterCertificateThumbprint) + d.Set("vmotion_network", props.VmotionNetwork) + } + d.Set("sku_name", resp.Sku.Name) + return tags.FlattenAndSet(d, resp.Tags) } func resourceArmAvsPrivateCloudUpdate(d *schema.ResourceData, meta interface{}) error { - client := meta.(*clients.Client).Avs.PrivateCloudClient - ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d) - defer cancel() - - id, err := parse.AvsPrivateCloudID(d.Id()) - if err != nil { - return err - } - - privateCloudUpdate := avs.PrivateCloudUpdate{ - PrivateCloudUpdateProperties: &avs.PrivateCloudUpdateProperties{ - }, - } - if d.HasChange("management_cluster") { - privateCloudUpdate.PrivateCloudUpdateProperties.ManagementCluster = expandArmPrivateCloudManagementCluster(d.Get("management_cluster").([]interface{})) - } - if d.HasChange("internet") { - internet := avs.Disabled - if d.Get("internet").(bool) { - internet = avs.Enabled - } - privateCloudUpdate.PrivateCloudUpdateProperties.Internet = internet - } - if d.HasChange("identity_source") { - privateCloudUpdate.PrivateCloudUpdateProperties.IdentitySources = expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()) - } - if d.HasChange("tags") { - privateCloudUpdate.Tags = tags.Expand(d.Get("tags").(map[string]interface{})) - } - - future, err :=client.Update(ctx, id.ResourceGroup, id.Name, privateCloudUpdate) - if err != nil { - return fmt.Errorf("updating Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) - } - - if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { - return fmt.Errorf("waiting on updating future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) - } - return resourceArmAvsPrivateCloudRead(d, meta) + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsPrivateCloudID(d.Id()) + if err != nil { + return err + } + + privateCloudUpdate := avs.PrivateCloudUpdate{ + PrivateCloudUpdateProperties: &avs.PrivateCloudUpdateProperties{}, + } + if d.HasChange("management_cluster") { + privateCloudUpdate.PrivateCloudUpdateProperties.ManagementCluster = &avs.ManagementCluster{ + ClusterSize: utils.Int32(int32(d.Get("management_cluster.0.cluster_size").(int))), + } + } + if d.HasChange("internet_connected") { + internet := avs.Disabled + if d.Get("internet").(bool) { + internet = avs.Enabled + } + privateCloudUpdate.PrivateCloudUpdateProperties.Internet = internet + } + if d.HasChange("identity_source") { + privateCloudUpdate.PrivateCloudUpdateProperties.IdentitySources = expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()) + } + if d.HasChange("tags") { + privateCloudUpdate.Tags = tags.Expand(d.Get("tags").(map[string]interface{})) + } + + future, err := client.Update(ctx, id.ResourceGroup, id.Name, privateCloudUpdate) + if err != nil { + return fmt.Errorf("updating Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on updating future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + return resourceArmAvsPrivateCloudRead(d, meta) } func resourceArmAvsPrivateCloudDelete(d *schema.ResourceData, meta interface{}) error { - client := meta.(*clients.Client).Avs.PrivateCloudClient - ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) - defer cancel() - - id, err := parse.AvsPrivateCloudID(d.Id()) - if err != nil { - return err - } - - future, err :=client.Delete(ctx, id.ResourceGroup, id.Name) - if err != nil { - return fmt.Errorf("deleting Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) - } - - if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { - return fmt.Errorf("waiting on deleting future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) - } - return nil -} - -func expandArmPrivateCloudSku(input []interface{}) *avs.Sku { - if len(input) == 0 { - return nil - } - v := input[0].(map[string]interface{}) - return &avs.Sku{ - Name: utils.String(v["name"].(string)), - } -} - -func expandArmPrivateCloudManagementCluster(input []interface{}) *avs.ManagementCluster { - if len(input) == 0 { - return nil - } - v := input[0].(map[string]interface{}) - return &avs.ManagementCluster{ - ClusterSize: utils.Int32(int32(v["cluster_size"].(int))), - } + client := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsPrivateCloudID(d.Id()) + if err != nil { + return err + } + + future, err := client.Delete(ctx, id.ResourceGroup, id.Name) + if err != nil { + return fmt.Errorf("deleting Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on deleting future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + } + return nil } func expandArmPrivateCloudIdentitySourceArray(input []interface{}) *[]avs.IdentitySource { - results := make([]avs.IdentitySource, 0) - for _, item := range input { - v := item.(map[string]interface{}) - sSL := avs.SslEnumDisabled - if v["ssl"].(bool) { - sSL = avs.SslEnumEnabled - } - result := avs.IdentitySource{ - Name: utils.String(v["name"].(string)), - Alias: utils.String(v["alias"].(string)), - Domain: utils.String(v["domain"].(string)), - BaseUserDN: utils.String(v["base_user_dn"].(string)), - BaseGroupDN: utils.String(v["base_group_dn"].(string)), - PrimaryServer: utils.String(v["primary_server"].(string)), - SecondaryServer: utils.String(v["secondary_server"].(string)), - Ssl: sSL, - Username: utils.String(v["username"].(string)), - Password: utils.String(v["password"].(string)), - } - results = append(results, result) - } - return &results + results := make([]avs.IdentitySource, 0) + for _, item := range input { + v := item.(map[string]interface{}) + sSL := avs.SslEnumDisabled + if v["ssl"].(bool) { + sSL = avs.SslEnumEnabled + } + result := avs.IdentitySource{ + Name: utils.String(v["name"].(string)), + Alias: utils.String(v["alias"].(string)), + Domain: utils.String(v["domain"].(string)), + BaseUserDN: utils.String(v["base_user_dn"].(string)), + BaseGroupDN: utils.String(v["base_group_dn"].(string)), + PrimaryServer: utils.String(v["primary_server_url"].(string)), + SecondaryServer: utils.String(v["secondary_server_url"].(string)), + Ssl: sSL, + Username: utils.String(v["username"].(string)), + Password: utils.String(v["password"].(string)), + } + results = append(results, result) + } + return &results } func flattenArmPrivateCloudManagementCluster(input *avs.ManagementCluster) []interface{} { - if input == nil { - return make([]interface{}, 0) - } - - var clusterSize int32 - if input.ClusterSize != nil { - clusterSize = *input.ClusterSize - } - var clusterId int32 - if input.ClusterID != nil { - clusterId = *input.ClusterID - } - return []interface{}{ - map[string]interface{}{ - "cluster_size": clusterSize, - "cluster_id": clusterId, - "hosts": utils.FlattenStringSlice(input.Hosts), - }, - } + if input == nil { + return make([]interface{}, 0) + } + + var clusterSize int32 + if input.ClusterSize != nil { + clusterSize = *input.ClusterSize + } + var clusterId int32 + if input.ClusterID != nil { + clusterId = *input.ClusterID + } + return []interface{}{ + map[string]interface{}{ + "cluster_size": clusterSize, + "cluster_id": clusterId, + "hosts": utils.FlattenStringSlice(input.Hosts), + }, + } } func flattenArmPrivateCloudCircuit(input *avs.Circuit) []interface{} { - if input == nil { - return make([]interface{}, 0) - } - - var expressRouteId string - if input.ExpressRouteID != nil { - expressRouteId = *input.ExpressRouteID - } - var expressRoutePrivatePeeringId string - if input.ExpressRoutePrivatePeeringID != nil { - expressRoutePrivatePeeringId = *input.ExpressRoutePrivatePeeringID - } - var primarySubnet string - if input.PrimarySubnet != nil { - primarySubnet = *input.PrimarySubnet - } - var secondarySubnet string - if input.SecondarySubnet != nil { - secondarySubnet = *input.SecondarySubnet - } - return []interface{}{ - map[string]interface{}{ - "express_route_id": expressRouteId, - "express_route_private_peering_id": expressRoutePrivatePeeringId, - "primary_subnet": primarySubnet, - "secondary_subnet": secondarySubnet, - }, - } + if input == nil { + return make([]interface{}, 0) + } + + var expressRouteId string + if input.ExpressRouteID != nil { + expressRouteId = *input.ExpressRouteID + } + var expressRoutePrivatePeeringId string + if input.ExpressRoutePrivatePeeringID != nil { + expressRoutePrivatePeeringId = *input.ExpressRoutePrivatePeeringID + } + var primarySubnet string + if input.PrimarySubnet != nil { + primarySubnet = *input.PrimarySubnet + } + var secondarySubnet string + if input.SecondarySubnet != nil { + secondarySubnet = *input.SecondarySubnet + } + return []interface{}{ + map[string]interface{}{ + "express_route_id": expressRouteId, + "express_route_private_peering_id": expressRoutePrivatePeeringId, + "primary_subnet": primarySubnet, + "secondary_subnet": secondarySubnet, + }, + } } func flattenArmPrivateCloudIdentitySourceArray(input *[]avs.IdentitySource) []interface{} { - results := make([]interface{}, 0) - if input == nil { - return results - } - - for _, item := range *input { - var name string - if item.Name != nil { - name = *item.Name - } - var alias string - if item.Alias != nil { - alias = *item.Alias - } - var baseGroupDn string - if item.BaseGroupDN != nil { - baseGroupDn = *item.BaseGroupDN - } - var baseUserDn string - if item.BaseUserDN != nil { - baseUserDn = *item.BaseUserDN - } - var domain string - if item.Domain != nil { - domain = *item.Domain - } - var password string - if item.Password != nil { - password = *item.Password - } - var primaryServer string - if item.PrimaryServer != nil { - primaryServer = *item.PrimaryServer - } - var secondaryServer string - if item.SecondaryServer != nil { - secondaryServer = *item.SecondaryServer - } - sSL := item.Ssl==avs.SslEnumEnabled - var username string - if item.Username != nil { - username = *item.Username - } - v := map[string]interface{}{ - "name": name, - "alias": alias, - "base_group_dn": baseGroupDn, - "base_user_dn": baseUserDn, - "domain": domain, - "password": password, - "primary_server": primaryServer, - "secondary_server": secondaryServer, - "ssl": sSL, - "username": username, - } - results = append(results, v) - } - return results -} - -func flattenArmPrivateCloudEndpoints(input *avs.Endpoints) []interface{} { - if input == nil { - return make([]interface{}, 0) - } - - var hcxCloudManager string - if input.HcxCloudManager != nil { - hcxCloudManager = *input.HcxCloudManager - } - var nsxtManager string - if input.NsxtManager != nil { - nsxtManager = *input.NsxtManager - } - var vcsa string - if input.Vcsa != nil { - vcsa = *input.Vcsa - } - return []interface{}{ - map[string]interface{}{ - "hcx_cloud_manager": hcxCloudManager, - "nsxt_manager": nsxtManager, - "vcsa": vcsa, - }, - } -} - -func flattenArmPrivateCloudSku(input *avs.Sku) []interface{} { - if input == nil { - return make([]interface{}, 0) - } - - var name string - if input.Name != nil { - name = *input.Name - } - return []interface{}{ - map[string]interface{}{ - "name": name, - }, - } + results := make([]interface{}, 0) + if input == nil { + return results + } + + for _, item := range *input { + var name string + if item.Name != nil { + name = *item.Name + } + var alias string + if item.Alias != nil { + alias = *item.Alias + } + var baseGroupDn string + if item.BaseGroupDN != nil { + baseGroupDn = *item.BaseGroupDN + } + var baseUserDn string + if item.BaseUserDN != nil { + baseUserDn = *item.BaseUserDN + } + var domain string + if item.Domain != nil { + domain = *item.Domain + } + var password string + if item.Password != nil { + password = *item.Password + } + var primaryServer string + if item.PrimaryServer != nil { + primaryServer = *item.PrimaryServer + } + var secondaryServer string + if item.SecondaryServer != nil { + secondaryServer = *item.SecondaryServer + } + sSL := item.Ssl == avs.SslEnumEnabled + var username string + if item.Username != nil { + username = *item.Username + } + v := map[string]interface{}{ + "name": name, + "alias": alias, + "base_group_dn": baseGroupDn, + "base_user_dn": baseUserDn, + "domain": domain, + "password": password, + "primary_server_url": primaryServer, + "secondary_server_url": secondaryServer, + "ssl_enabled": sSL, + "username": username, + } + results = append(results, v) + } + return results } diff --git a/azurerm/internal/services/avs/client/client.go b/azurerm/internal/services/avs/client/client.go index dff68a01c8c5..ca0362e7231b 100644 --- a/azurerm/internal/services/avs/client/client.go +++ b/azurerm/internal/services/avs/client/client.go @@ -1,33 +1,19 @@ package client import ( - "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/common" + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/common" ) + type Client struct { - PrivateCloudClient *avs.PrivateCloudsClient - ClusterClient *avs.ClustersClient - HcxEnterpriseSiteClient *avs.HcxEnterpriseSitesClient - AuthorizationClient *avs.AuthorizationsClient + PrivateCloudClient *avs.PrivateCloudsClient } func NewClient(o *common.ClientOptions) *Client { - privateCloudClient := avs.NewPrivateCloudsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) - o.ConfigureClient(&privateCloudClient.Client, o.ResourceManagerAuthorizer) - - clusterClient := avs.NewClustersClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) - o.ConfigureClient(&clusterClient.Client, o.ResourceManagerAuthorizer) - - hcxEnterpriseSiteClient := avs.NewHcxEnterpriseSitesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) - o.ConfigureClient(&hcxEnterpriseSiteClient.Client, o.ResourceManagerAuthorizer) - - authorizationClient := avs.NewAuthorizationsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) - o.ConfigureClient(&authorizationClient.Client, o.ResourceManagerAuthorizer) + privateCloudClient := avs.NewPrivateCloudsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&privateCloudClient.Client, o.ResourceManagerAuthorizer) - return &Client{ - PrivateCloudClient: &privateCloudClient, - ClusterClient: &clusterClient, - HcxEnterpriseSiteClient: &hcxEnterpriseSiteClient, - AuthorizationClient: &authorizationClient, - } + return &Client{ + PrivateCloudClient: &privateCloudClient, + } } diff --git a/azurerm/internal/services/avs/parse/avs_authorizations.go b/azurerm/internal/services/avs/parse/avs_authorizations.go deleted file mode 100644 index 2a731776e466..000000000000 --- a/azurerm/internal/services/avs/parse/avs_authorizations.go +++ /dev/null @@ -1,32 +0,0 @@ -package parse -import ( - "fmt" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" -) -type AvsAuthorizationId struct { - ResourceGroup string - PrivateCloudName string - Name string -} - -func AvsAuthorizationID(input string) (*AvsAuthorizationId, error) { - id, err := azure.ParseAzureResourceID(input) - if err != nil { - return nil, fmt.Errorf("parsing avsAuthorization ID %q: %+v", input, err) - } - - avsAuthorization := AvsAuthorizationId{ - ResourceGroup: id.ResourceGroup, - } - if avsAuthorization.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { - return nil, err - } - if avsAuthorization.Name, err = id.PopSegment("authorizations"); err != nil { - return nil, err - } - if err := id.ValidateNoEmptySegments(input); err != nil { - return nil, err - } - - return &avsAuthorization, nil -} diff --git a/azurerm/internal/services/avs/parse/avs_authorizations_test.go b/azurerm/internal/services/avs/parse/avs_authorizations_test.go deleted file mode 100644 index 92aa90a0119c..000000000000 --- a/azurerm/internal/services/avs/parse/avs_authorizations_test.go +++ /dev/null @@ -1,77 +0,0 @@ -package parse - -import ( - "testing" -) - -func TestAvsAuthorizationID(t *testing.T) { - testData := []struct { - Name string - Input string - Expected *AvsAuthorizationId - }{ - { - Name: "Empty", - Input: "", - Expected: nil, - }, - { - Name: "No Resource Groups Segment", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000", - Expected: nil, - }, - { - Name: "No Resource Groups Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", - Expected: nil, - }, - { - Name: "Resource Group ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", - Expected: nil, - }, - { - Name: "Missing Authorization Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations", - Expected: nil, - }, - { - Name: "avs Authorization ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1", - Expected: &AvsAuthorizationId{ - ResourceGroup:"resourceGroup1", - PrivateCloudName:"privateCloud1", - Name:"authorization1", - }, - }, - { - Name: "Wrong Casing", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/Authorizations/authorization1", - Expected: nil, - }, - } - - for _, v := range testData { - t.Logf("[DEBUG] Testing %q..", v.Name) - - actual, err := AvsAuthorizationID(v.Input) - if err != nil { - if v.Expected == nil { - continue - } - t.Fatalf("Expected a value but got an error: %s", err) - } - - if actual.ResourceGroup != v.Expected.ResourceGroup { - t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) - } - - if actual.PrivateCloudName != v.Expected.PrivateCloudName { - t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) - } - - if actual.Name != v.Expected.Name { - t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) - } - } -} diff --git a/azurerm/internal/services/avs/parse/avs_clusters.go b/azurerm/internal/services/avs/parse/avs_clusters.go deleted file mode 100644 index baa1b08c9e4d..000000000000 --- a/azurerm/internal/services/avs/parse/avs_clusters.go +++ /dev/null @@ -1,33 +0,0 @@ -package parse - -import ( - "fmt" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" -) -type AvsClusterId struct { - ResourceGroup string - PrivateCloudName string - Name string -} - -func AvsClusterID(input string) (*AvsClusterId, error) { - id, err := azure.ParseAzureResourceID(input) - if err != nil { - return nil, fmt.Errorf("parsing avsCluster ID %q: %+v", input, err) - } - - avsCluster := AvsClusterId{ - ResourceGroup: id.ResourceGroup, - } - if avsCluster.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { - return nil, err - } - if avsCluster.Name, err = id.PopSegment("clusters"); err != nil { - return nil, err - } - if err := id.ValidateNoEmptySegments(input); err != nil { - return nil, err - } - - return &avsCluster, nil -} diff --git a/azurerm/internal/services/avs/parse/avs_clusters_test.go b/azurerm/internal/services/avs/parse/avs_clusters_test.go deleted file mode 100644 index 15ad350cdf91..000000000000 --- a/azurerm/internal/services/avs/parse/avs_clusters_test.go +++ /dev/null @@ -1,77 +0,0 @@ -package parse - -import ( - "testing" -) - -func TestAvsClusterID(t *testing.T) { - testData := []struct { - Name string - Input string - Expected *AvsClusterId - }{ - { - Name: "Empty", - Input: "", - Expected: nil, - }, - { - Name: "No Resource Groups Segment", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000", - Expected: nil, - }, - { - Name: "No Resource Groups Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", - Expected: nil, - }, - { - Name: "Resource Group ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", - Expected: nil, - }, - { - Name: "Missing Cluster Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters", - Expected: nil, - }, - { - Name: "avs Cluster ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters/cluster1", - Expected: &AvsClusterId{ - ResourceGroup:"resourceGroup1", - PrivateCloudName:"privateCloud1", - Name:"cluster1", - }, - }, - { - Name: "Wrong Casing", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/Clusters/cluster1", - Expected: nil, - }, - } - - for _, v := range testData { - t.Logf("[DEBUG] Testing %q..", v.Name) - - actual, err := AvsClusterID(v.Input) - if err != nil { - if v.Expected == nil { - continue - } - t.Fatalf("Expected a value but got an error: %s", err) - } - - if actual.ResourceGroup != v.Expected.ResourceGroup { - t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) - } - - if actual.PrivateCloudName != v.Expected.PrivateCloudName { - t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) - } - - if actual.Name != v.Expected.Name { - t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) - } - } -} diff --git a/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go b/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go deleted file mode 100644 index a6dbc043d15a..000000000000 --- a/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites.go +++ /dev/null @@ -1,33 +0,0 @@ -package parse - -import ( - "fmt" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" -) -type AvsHcxEnterpriseSiteId struct { - ResourceGroup string - PrivateCloudName string - Name string -} - -func AvsHcxEnterpriseSiteID(input string) (*AvsHcxEnterpriseSiteId, error) { - id, err := azure.ParseAzureResourceID(input) - if err != nil { - return nil, fmt.Errorf("parsing avsHcxEnterpriseSite ID %q: %+v", input, err) - } - - avsHcxEnterpriseSite := AvsHcxEnterpriseSiteId{ - ResourceGroup: id.ResourceGroup, - } - if avsHcxEnterpriseSite.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { - return nil, err - } - if avsHcxEnterpriseSite.Name, err = id.PopSegment("hcxEnterpriseSites"); err != nil { - return nil, err - } - if err := id.ValidateNoEmptySegments(input); err != nil { - return nil, err - } - - return &avsHcxEnterpriseSite, nil -} diff --git a/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go b/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go deleted file mode 100644 index 446154273fe2..000000000000 --- a/azurerm/internal/services/avs/parse/avs_hcx_enterprise_sites_test.go +++ /dev/null @@ -1,77 +0,0 @@ -package parse - -import ( - "testing" -) - -func TestAvsHcxEnterpriseSiteID(t *testing.T) { - testData := []struct { - Name string - Input string - Expected *AvsHcxEnterpriseSiteId - }{ - { - Name: "Empty", - Input: "", - Expected: nil, - }, - { - Name: "No Resource Groups Segment", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000", - Expected: nil, - }, - { - Name: "No Resource Groups Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", - Expected: nil, - }, - { - Name: "Resource Group ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", - Expected: nil, - }, - { - Name: "Missing HcxEnterpriseSite Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/hcxEnterpriseSites", - Expected: nil, - }, - { - Name: "avs HcxEnterpriseSite ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/hcxEnterpriseSites/hcxEnterpriseSite1", - Expected: &AvsHcxEnterpriseSiteId{ - ResourceGroup:"resourceGroup1", - PrivateCloudName:"privateCloud1", - Name:"hcxEnterpriseSite1", - }, - }, - { - Name: "Wrong Casing", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/HcxEnterpriseSites/hcxEnterpriseSite1", - Expected: nil, - }, - } - - for _, v := range testData { - t.Logf("[DEBUG] Testing %q..", v.Name) - - actual, err := AvsHcxEnterpriseSiteID(v.Input) - if err != nil { - if v.Expected == nil { - continue - } - t.Fatalf("Expected a value but got an error: %s", err) - } - - if actual.ResourceGroup != v.Expected.ResourceGroup { - t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) - } - - if actual.PrivateCloudName != v.Expected.PrivateCloudName { - t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) - } - - if actual.Name != v.Expected.Name { - t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) - } - } -} diff --git a/azurerm/internal/services/avs/parse/avs_private_clouds.go b/azurerm/internal/services/avs/parse/avs_private_clouds.go index 631f7e3367fb..6f0de3451d96 100644 --- a/azurerm/internal/services/avs/parse/avs_private_clouds.go +++ b/azurerm/internal/services/avs/parse/avs_private_clouds.go @@ -1,29 +1,30 @@ package parse import ( - "fmt" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" ) + type AvsPrivateCloudId struct { - ResourceGroup string - Name string + ResourceGroup string + Name string } func AvsPrivateCloudID(input string) (*AvsPrivateCloudId, error) { - id, err := azure.ParseAzureResourceID(input) - if err != nil { - return nil, fmt.Errorf("parsing avsPrivateCloud ID %q: %+v", input, err) - } + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsPrivateCloud ID %q: %+v", input, err) + } - avsPrivateCloud := AvsPrivateCloudId{ - ResourceGroup: id.ResourceGroup, - } - if avsPrivateCloud.Name, err = id.PopSegment("privateClouds"); err != nil { - return nil, err - } - if err := id.ValidateNoEmptySegments(input); err != nil { - return nil, err - } + avsPrivateCloud := AvsPrivateCloudId{ + ResourceGroup: id.ResourceGroup, + } + if avsPrivateCloud.Name, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } - return &avsPrivateCloud, nil + return &avsPrivateCloud, nil } diff --git a/azurerm/internal/services/avs/parse/avs_private_clouds_test.go b/azurerm/internal/services/avs/parse/avs_private_clouds_test.go index aae5c201712b..ba5a75d5f4f3 100644 --- a/azurerm/internal/services/avs/parse/avs_private_clouds_test.go +++ b/azurerm/internal/services/avs/parse/avs_private_clouds_test.go @@ -1,72 +1,72 @@ package parse import ( - "testing" + "testing" ) func TestAvsPrivateCloudID(t *testing.T) { - testData := []struct { - Name string - Input string - Expected *AvsPrivateCloudId - }{ - { - Name: "Empty", - Input: "", - Expected: nil, - }, - { - Name: "No Resource Groups Segment", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000", - Expected: nil, - }, - { - Name: "No Resource Groups Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", - Expected: nil, - }, - { - Name: "Resource Group ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", - Expected: nil, - }, - { - Name: "Missing PrivateCloud Value", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds", - Expected: nil, - }, - { - Name: "avs PrivateCloud ID", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1", - Expected: &AvsPrivateCloudId{ - ResourceGroup:"resourceGroup1", - Name:"privateCloud1", - }, - }, - { - Name: "Wrong Casing", - Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/PrivateClouds/privateCloud1", - Expected: nil, - }, - } + testData := []struct { + Name string + Input string + Expected *AvsPrivateCloudId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing PrivateCloud Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds", + Expected: nil, + }, + { + Name: "avs PrivateCloud ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1", + Expected: &AvsPrivateCloudId{ + ResourceGroup: "resourceGroup1", + Name: "privateCloud1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/PrivateClouds/privateCloud1", + Expected: nil, + }, + } - for _, v := range testData { - t.Logf("[DEBUG] Testing %q..", v.Name) + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) - actual, err := AvsPrivateCloudID(v.Input) - if err != nil { - if v.Expected == nil { - continue - } - t.Fatalf("Expected a value but got an error: %s", err) - } + actual, err := AvsPrivateCloudID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } - if actual.ResourceGroup != v.Expected.ResourceGroup { - t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) - } + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } - if actual.Name != v.Expected.Name { - t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) - } - } + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } } diff --git a/azurerm/internal/services/avs/registration.go b/azurerm/internal/services/avs/registration.go index 265fd5bdcb7a..f6d02a09485a 100644 --- a/azurerm/internal/services/avs/registration.go +++ b/azurerm/internal/services/avs/registration.go @@ -6,32 +6,26 @@ type Registration struct{} // Name is the name of this Service func (r Registration) Name() string { - return "Avs" + return "Avs" } // WebsiteCategories returns a list of categories which can be used for the sidebar func (r Registration) WebsiteCategories() []string { - return []string{ - "Avs", - } + return []string{ + "Avs", + } } // SupportedDataSources returns the supported Data Sources supported by this Service func (r Registration) SupportedDataSources() map[string]*schema.Resource { - return map[string]*schema.Resource{ - "azurerm_avs_private_cloud": dataSourceAvsPrivateCloud(), - "azurerm_avs_cluster": dataSourceAvsCluster(), - "azurerm_avs_hcx_enterprise_site": dataSourceAvsHcxEnterpriseSite(), - "azurerm_avs_authorization": dataSourceAvsAuthorization(), - } + return map[string]*schema.Resource{ + "azurerm_avs_private_cloud": dataSourceAvsPrivateCloud(), + } } // SupportedResources returns the supported Resources supported by this Service func (r Registration) SupportedResources() map[string]*schema.Resource { - return map[string]*schema.Resource{ - "azurerm_avs_private_cloud": resourceArmAvsPrivateCloud(), - "azurerm_avs_cluster": resourceArmAvsCluster(), - "azurerm_avs_hcx_enterprise_site": resourceArmAvsHcxEnterpriseSite(), - "azurerm_avs_authorization": resourceArmAvsAuthorization(), - } + return map[string]*schema.Resource{ + "azurerm_avs_private_cloud": resourceArmAvsPrivateCloud(), + } } diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go index d84a4baa121a..c9e5acf2c8e6 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go @@ -1,31 +1,32 @@ package tests import ( - "fmt" - "github.com/hashicorp/terraform-plugin-sdk/helper/resource" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" - "testing" + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" + "testing" ) + func TestAccDataSourceAzureRMavsPrivateCloud_basic(t *testing.T) { - data := acceptance.BuildTestData(t, "data.azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccDataSourceavsPrivateCloud_basic(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - }, - }) + data := acceptance.BuildTestData(t, "data.azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccDataSourceavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + }, + }) } func testAccDataSourceavsPrivateCloud_basic(data acceptance.TestData) string { - config := testAccAzureRMavsPrivateCloud_basic(data) - return fmt.Sprintf(` + config := testAccAzureRMavsPrivateCloud_basic(data) + return fmt.Sprintf(` %s data "azurerm_avs_private_cloud" "test" { diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 7450e4db545f..586110f8a203 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -1,198 +1,299 @@ package tests import ( - "fmt" - "github.com/hashicorp/terraform-plugin-sdk/helper/resource" - "github.com/hashicorp/terraform-plugin-sdk/terraform" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" - "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" - "testing" + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "testing" ) func TestAccAzureRMavsPrivateCloud_basic(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_basic(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - }, - }) + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + }, + }) } func TestAccAzureRMavsPrivateCloud_requiresImport(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_basic(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.RequiresImportErrorStep(testAccAzureRMavsPrivateCloud_requiresImport), - }, - }) + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.RequiresImportErrorStep(testAccAzureRMavsPrivateCloud_requiresImport), + }, + }) } func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_complete(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - }, - }) + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_complete(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + }, + }) } func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_basic(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - { - Config: testAccAzureRMavsPrivateCloud_complete(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - { - Config: testAccAzureRMavsPrivateCloud_basic(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - }, - }) -} - -func TestAccAzureRMavsPrivateCloud_updateManagementCluster(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_complete(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - { - Config: testAccAzureRMavsPrivateCloud_updateManagementCluster(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - }, - }) + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_complete(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_update(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + }, + }) } func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_complete(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - { - Config: testAccAzureRMavsPrivateCloud_updateIdentitySources(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep(), - }, - }) + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsPrivateCloud_complete(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_updateIdentitySources(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsPrivateCloud_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), + ), + }, + data.ImportStep(), + }, + }) } func testCheckAzureRMavsPrivateCloudExists(resourceName string) resource.TestCheckFunc { - return func(s *terraform.State) error { - client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.PrivateCloudClient - ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext - rs, ok := s.RootModule().Resources[resourceName] - if !ok { - return fmt.Errorf("avs PrivateCloud not found: %s", resourceName) - } - id, err := parse.AvsPrivateCloudID(rs.Primary.ID) - if err != nil { - return err - } - if resp, err := client.Get(ctx, id.ResourceGroup, id.Name); err != nil { - if !utils.ResponseWasNotFound(resp.Response) { - return fmt.Errorf("bad: Avs PrivateCloud %q does not exist", id.Name) - } - return fmt.Errorf("bad: Get on Avs.PrivateCloudClient: %+v", err) - } - return nil - } + return func(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.PrivateCloudClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("avs PrivateCloud not found: %s", resourceName) + } + id, err := parse.AvsPrivateCloudID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Avs PrivateCloud %q does not exist", id.Name) + } + return fmt.Errorf("bad: Get on Avs.PrivateCloudClient: %+v", err) + } + return nil + } } func testCheckAzureRMavsPrivateCloudDestroy(s *terraform.State) error { - client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.PrivateCloudClient - ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.PrivateCloudClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext - for _, rs := range s.RootModule().Resources { - if rs.Type != "azurerm_avs_private_cloud" { - continue - } - id, err := parse.AvsPrivateCloudID(rs.Primary.ID) - if err != nil { - return err - } - if resp, err := client.Get(ctx, id.ResourceGroup, id.Name); err != nil { - if !utils.ResponseWasNotFound(resp.Response) { - return fmt.Errorf("bad: Get on Avs.PrivateCloudClient: %+v", err) - } - } - return nil - } - return nil + for _, rs := range s.RootModule().Resources { + if rs.Type != "azurerm_avs_private_cloud" { + continue + } + id, err := parse.AvsPrivateCloudID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Get on Avs.PrivateCloudClient: %+v", err) + } + } + return nil + } + return nil } func testAccAzureRMavsPrivateCloud_template(data acceptance.TestData) string { - return fmt.Sprintf(` + return fmt.Sprintf(` provider "azurerm" { features {} } @@ -205,17 +306,15 @@ resource "azurerm_resource_group" "test" { } func testAccAzureRMavsPrivateCloud_basic(data acceptance.TestData) string { - template := testAccAzureRMavsPrivateCloud_template(data) - return fmt.Sprintf(` + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-apc-%d" resource_group_name = azurerm_resource_group.test.name - location = azurerm_resource_group.test.location - sku { - name = "av36" - } + location = azurerm_resource_group.test.location + sku_name = "av36" management_cluster { cluster_size = 4 @@ -226,19 +325,18 @@ resource "azurerm_avs_private_cloud" "test" { } func testAccAzureRMavsPrivateCloud_requiresImport(data acceptance.TestData) string { - config := testAccAzureRMavsPrivateCloud_basic(data) - return fmt.Sprintf(` + config := testAccAzureRMavsPrivateCloud_basic(data) + return fmt.Sprintf(` %s resource "azurerm_avs_private_cloud" "import" { - name = azurerm_avs_private_cloud.test.name + name = azurerm_avs_private_cloud.test.name resource_group_name = azurerm_avs_private_cloud.test.resource_group_name - location = azurerm_avs_private_cloud.test.location - sku { - name = azurerm_avs_private_cloud.test.sku.name - } + location = azurerm_avs_private_cloud.test.location + sku_name = azurerm_avs_private_cloud.test.sku_name + management_cluster { - cluster_size = azurerm_avs_private_cloud.test.management_cluster.cluster_size + cluster_size = azurerm_avs_private_cloud.test.management_cluster.0.cluster_size } network_block = azurerm_avs_private_cloud.test.network_block } @@ -246,37 +344,35 @@ resource "azurerm_avs_private_cloud" "import" { } func testAccAzureRMavsPrivateCloud_complete(data acceptance.TestData) string { - template := testAccAzureRMavsPrivateCloud_template(data) - return fmt.Sprintf(` + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-apc-%d" resource_group_name = azurerm_resource_group.test.name - location = azurerm_resource_group.test.location - sku { - name = "AV36" - } + location = azurerm_resource_group.test.location + sku_name = "AV36" management_cluster { cluster_size = 4 } network_block = "192.168.48.0/22" identity_source { - name = "" - alias = "" - base_group_dn = "" - base_user_dn = "" - domain = "" - password = "" - primary_server = "" - secondary_server = "" - ssl = false - username = "" + name = "testName" + alias = "testAlias" + base_group_dn = "testGp" + base_user_dn = "testUser" + domain = "testDomain" + password = "PassWord1234!" + primary_server_url = "http://test.com" + secondary_server_url = "http://test2.com" + ssl_enabled = false + username = "testUser" } - internet = false - nsxt_password = "" - vcenter_password = "" + internet_connected = false + nsxt_password = "PassWord1234!" + vcenter_password = "PassWord1234!" tags = { ENV = "Test" } @@ -284,80 +380,88 @@ resource "azurerm_avs_private_cloud" "test" { `, template, data.RandomInteger) } -func testAccAzureRMavsPrivateCloud_updateManagementCluster(data acceptance.TestData) string { - template := testAccAzureRMavsPrivateCloud_template(data) - return fmt.Sprintf(` +func testAccAzureRMavsPrivateCloud_update(data acceptance.TestData) string { + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-apc-%d" resource_group_name = azurerm_resource_group.test.name - location = azurerm_resource_group.test.location - sku { - name = "AV36" - } + location = azurerm_resource_group.test.location + sku_name = "AV36" management_cluster { - cluster_size = 4 + cluster_size = 3 } network_block = "192.168.48.0/22" identity_source { - name = "" - alias = "" - base_group_dn = "" - base_user_dn = "" - domain = "" - password = "" - primary_server = "" - secondary_server = "" - ssl = false - username = "" + name = "testName2" + alias = "testAlias2" + base_group_dn = "testGp2" + base_user_dn = "testUser2" + domain = "testDomain2" + password = "PassWord1234!2" + primary_server_url = "http://test_secondary.com" + secondary_server_url = "http://test_secondary2.com" + ssl_enabled = true + username = "testUser2" } - internet = false - nsxt_password = "" - vcenter_password = "" + internet_connected = true + nsxt_password = "PassWord1234!" + vcenter_password = "PassWord1234!" tags = { - ENV = "Test" + ENV = "Stage" } } `, template, data.RandomInteger) } func testAccAzureRMavsPrivateCloud_updateIdentitySources(data acceptance.TestData) string { - template := testAccAzureRMavsPrivateCloud_template(data) - return fmt.Sprintf(` + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` %s resource "azurerm_avs_private_cloud" "test" { name = "acctest-apc-%d" resource_group_name = azurerm_resource_group.test.name location = azurerm_resource_group.test.location - sku { - name = "AV36" - } + sku_name= "AV36" management_cluster { cluster_size = 4 } network_block = "192.168.48.0/22" identity_source { - name = "" - alias = "" - base_group_dn = "" - base_user_dn = "" - domain = "" - password = "" - primary_server = "" - secondary_server = "" - ssl = false - username = "" + name = "testName" + alias = "testAlias" + base_group_dn = "testGp" + base_user_dn = "testUser" + domain = "testDomain" + password = "PassWord1234!" + primary_server_url = "http://test.com" + secondary_server_url = "http://test2.com" + ssl_enabled = false + username = "testUser" + } + +identity_source { + name = "testName3" + alias = "testAlias3" + base_group_dn = "testGp3" + base_user_dn = "testUser3" + domain = "testDomain3" + password = "PassWord1234!3" + primary_server_url = "http://test_secondary.com" + secondary_server_url = "http://test_secondary2.com" + ssl_enabled = true + username = "testUser3" } - internet = false - nsxt_password = "" - vcenter_password = "" + internet_connected = false + nsxt_password = "PassWord1234!" + vcenter_password = "PassWord1234!" tags = { ENV = "Test" } -} `, template, data.RandomInteger) } diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go index e8cc967e2088..34bb4663ebe7 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/authorizations.go @@ -1,432 +1,429 @@ -package avs - -// 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" -) - -// AuthorizationsClient is the azure VMware Solution API -type AuthorizationsClient struct { - BaseClient -} - -// NewAuthorizationsClient creates an instance of the AuthorizationsClient client. -func NewAuthorizationsClient(subscriptionID string) AuthorizationsClient { - return NewAuthorizationsClientWithBaseURI(DefaultBaseURI, subscriptionID) -} - -// NewAuthorizationsClientWithBaseURI creates an instance of the AuthorizationsClient 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 NewAuthorizationsClientWithBaseURI(baseURI string, subscriptionID string) AuthorizationsClient { - return AuthorizationsClient{NewWithBaseURI(baseURI, subscriptionID)} -} - -// CreateOrUpdate sends the create or update request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - the name of the private cloud. -// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud -// authorization - an ExpressRoute Circuit Authorization -func (client AuthorizationsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (result AuthorizationsCreateOrUpdateFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.AuthorizationsClient", "CreateOrUpdate", err.Error()) - } - - req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, authorizationName, authorization) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "CreateOrUpdate", nil, "Failure preparing request") - return - } - - result, err = client.CreateOrUpdateSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "CreateOrUpdate", result.Response(), "Failure sending request") - return - } - - return -} - -// CreateOrUpdatePreparer prepares the CreateOrUpdate request. -func (client AuthorizationsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "authorizationName": autorest.Encode("path", authorizationName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - 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.AVS/privateClouds/{privateCloudName}/authorizations/{authorizationName}", pathParameters), - autorest.WithJSON(authorization), - 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 AuthorizationsClient) CreateOrUpdateSender(req *http.Request) (future AuthorizationsCreateOrUpdateFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always -// closes the http.Response Body. -func (client AuthorizationsClient) CreateOrUpdateResponder(resp *http.Response) (result ExpressRouteAuthorization, 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 sends the delete request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud -func (client AuthorizationsClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result AuthorizationsDeleteFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.AuthorizationsClient", "Delete", err.Error()) - } - - req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, authorizationName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Delete", nil, "Failure preparing request") - return - } - - result, err = client.DeleteSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Delete", result.Response(), "Failure sending request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client AuthorizationsClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "authorizationName": autorest.Encode("path", authorizationName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) DeleteSender(req *http.Request) (future AuthorizationsDeleteFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client AuthorizationsClient) 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 sends the get request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud -func (client AuthorizationsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result ExpressRouteAuthorization, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.AuthorizationsClient", "Get", err.Error()) - } - - req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, authorizationName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", nil, "Failure preparing request") - return - } - - resp, err := client.GetSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", resp, "Failure sending request") - return - } - - result, err = client.GetResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", resp, "Failure responding to request") - } - - return -} - -// GetPreparer prepares the Get request. -func (client AuthorizationsClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "authorizationName": autorest.Encode("path", authorizationName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) 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 AuthorizationsClient) GetResponder(resp *http.Response) (result ExpressRouteAuthorization, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -// List sends the list request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -func (client AuthorizationsClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result ExpressRouteAuthorizationListPage, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.List") - defer func() { - sc := -1 - if result.eral.Response.Response != nil { - sc = result.eral.Response.Response.StatusCode - } - tracing.EndSpan(ctx, sc, err) - }() - } - if err := validation.Validate([]validation.Validation{ - {TargetValue: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.AuthorizationsClient", "List", err.Error()) - } - - result.fn = client.listNextResults - req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", nil, "Failure preparing request") - return - } - - resp, err := client.ListSender(req) - if err != nil { - result.eral.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", resp, "Failure sending request") - return - } - - result.eral, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", resp, "Failure responding to request") - } - if result.eral.hasNextLink() && result.eral.IsEmpty() { - err = result.NextWithContext(ctx) - } - - return -} - -// ListPreparer prepares the List request. -func (client AuthorizationsClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) 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 AuthorizationsClient) ListResponder(resp *http.Response) (result ExpressRouteAuthorizationList, 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 AuthorizationsClient) listNextResults(ctx context.Context, lastResults ExpressRouteAuthorizationList) (result ExpressRouteAuthorizationList, err error) { - req, err := lastResults.expressRouteAuthorizationListPreparer(ctx) - if err != nil { - return result, autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "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, "avs.AuthorizationsClient", "listNextResults", resp, "Failure sending next results request") - } - result, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "listNextResults", resp, "Failure responding to next results request") - } - return -} - -// ListComplete enumerates all values, automatically crossing page boundaries as required. -func (client AuthorizationsClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result ExpressRouteAuthorizationListIterator, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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, privateCloudName) - return -} +package avs + +// 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" +) + +// AuthorizationsClient is the azure VMware Solution API +type AuthorizationsClient struct { + BaseClient +} + +// NewAuthorizationsClient creates an instance of the AuthorizationsClient client. +func NewAuthorizationsClient(subscriptionID string) AuthorizationsClient { + return NewAuthorizationsClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewAuthorizationsClientWithBaseURI creates an instance of the AuthorizationsClient 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 NewAuthorizationsClientWithBaseURI(baseURI string, subscriptionID string) AuthorizationsClient { + return AuthorizationsClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - the name of the private cloud. +// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud +// authorization - an ExpressRoute Circuit Authorization +func (client AuthorizationsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (result AuthorizationsCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, authorizationName, authorization) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client AuthorizationsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "authorizationName": autorest.Encode("path", authorizationName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/authorizations/{authorizationName}", pathParameters), + autorest.WithJSON(authorization), + 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 AuthorizationsClient) CreateOrUpdateSender(req *http.Request) (future AuthorizationsCreateOrUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client AuthorizationsClient) CreateOrUpdateResponder(resp *http.Response) (result ExpressRouteAuthorization, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud +func (client AuthorizationsClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result AuthorizationsDeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, authorizationName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client AuthorizationsClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "authorizationName": autorest.Encode("path", authorizationName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) DeleteSender(req *http.Request) (future AuthorizationsDeleteFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client AuthorizationsClient) 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 sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// authorizationName - name of the ExpressRoute Circuit Authorization in the private cloud +func (client AuthorizationsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result ExpressRouteAuthorization, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, authorizationName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client AuthorizationsClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "authorizationName": autorest.Encode("path", authorizationName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) 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 AuthorizationsClient) GetResponder(resp *http.Response) (result ExpressRouteAuthorization, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client AuthorizationsClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result ExpressRouteAuthorizationListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.List") + defer func() { + sc := -1 + if result.eral.Response.Response != nil { + sc = result.eral.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.AuthorizationsClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.eral.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", resp, "Failure sending request") + return + } + + result.eral, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client AuthorizationsClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/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 AuthorizationsClient) 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 AuthorizationsClient) ListResponder(resp *http.Response) (result ExpressRouteAuthorizationList, 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 AuthorizationsClient) listNextResults(ctx context.Context, lastResults ExpressRouteAuthorizationList) (result ExpressRouteAuthorizationList, err error) { + req, err := lastResults.expressRouteAuthorizationListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "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, "avs.AuthorizationsClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client AuthorizationsClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result ExpressRouteAuthorizationListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AuthorizationsClient.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, privateCloudName) + return +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go deleted file mode 100644 index eb7087c9474a..000000000000 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/avsapi/interfaces.go +++ /dev/null @@ -1,89 +0,0 @@ -package avsapi - -// 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/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" - "github.com/Azure/go-autorest/autorest" -) - -// OperationsClientAPI contains the set of methods on the OperationsClient type. -type OperationsClientAPI interface { - List(ctx context.Context) (result avs.OperationListPage, err error) - ListComplete(ctx context.Context) (result avs.OperationListIterator, err error) -} - -var _ OperationsClientAPI = (*avs.OperationsClient)(nil) - -// LocationsClientAPI contains the set of methods on the LocationsClient type. -type LocationsClientAPI interface { - CheckQuotaAvailability(ctx context.Context, location string) (result avs.Quota, err error) - CheckTrialAvailability(ctx context.Context, location string) (result avs.Trial, err error) -} - -var _ LocationsClientAPI = (*avs.LocationsClient)(nil) - -// PrivateCloudsClientAPI contains the set of methods on the PrivateCloudsClient type. -type PrivateCloudsClientAPI interface { - CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud avs.PrivateCloud) (result avs.PrivateCloudsCreateOrUpdateFuture, err error) - Delete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.PrivateCloudsDeleteFuture, err error) - Get(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.PrivateCloud, err error) - List(ctx context.Context, resourceGroupName string) (result avs.PrivateCloudListPage, err error) - ListComplete(ctx context.Context, resourceGroupName string) (result avs.PrivateCloudListIterator, err error) - ListAdminCredentials(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.AdminCredentials, err error) - ListInSubscription(ctx context.Context) (result avs.PrivateCloudListPage, err error) - ListInSubscriptionComplete(ctx context.Context) (result avs.PrivateCloudListIterator, err error) - Update(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate avs.PrivateCloudUpdate) (result avs.PrivateCloudsUpdateFuture, err error) -} - -var _ PrivateCloudsClientAPI = (*avs.PrivateCloudsClient)(nil) - -// ClustersClientAPI contains the set of methods on the ClustersClient type. -type ClustersClientAPI interface { - CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster avs.Cluster) (result avs.ClustersCreateOrUpdateFuture, err error) - Delete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result avs.ClustersDeleteFuture, err error) - Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result avs.Cluster, err error) - List(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ClusterListPage, err error) - ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ClusterListIterator, err error) - Update(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate avs.ClusterUpdate) (result avs.ClustersUpdateFuture, err error) -} - -var _ ClustersClientAPI = (*avs.ClustersClient)(nil) - -// HcxEnterpriseSitesClientAPI contains the set of methods on the HcxEnterpriseSitesClient type. -type HcxEnterpriseSitesClientAPI interface { - CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (result avs.HcxEnterpriseSite, err error) - Delete(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result autorest.Response, err error) - Get(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result avs.HcxEnterpriseSite, err error) - List(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.HcxEnterpriseSiteListPage, err error) - ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.HcxEnterpriseSiteListIterator, err error) -} - -var _ HcxEnterpriseSitesClientAPI = (*avs.HcxEnterpriseSitesClient)(nil) - -// AuthorizationsClientAPI contains the set of methods on the AuthorizationsClient type. -type AuthorizationsClientAPI interface { - CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string, authorization interface{}) (result avs.AuthorizationsCreateOrUpdateFuture, err error) - Delete(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result avs.AuthorizationsDeleteFuture, err error) - Get(ctx context.Context, resourceGroupName string, privateCloudName string, authorizationName string) (result avs.ExpressRouteAuthorization, err error) - List(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ExpressRouteAuthorizationListPage, err error) - ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result avs.ExpressRouteAuthorizationListIterator, err error) -} - -var _ AuthorizationsClientAPI = (*avs.AuthorizationsClient)(nil) diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go index f9b3fc4c05b3..9d82901763af 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/client.go @@ -1,52 +1,52 @@ -// Package avs implements the Azure ARM Avs service API version 2020-03-20. -// -// Azure VMware Solution API -package avs - -// 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 Avs - DefaultBaseURI = "https://management.azure.com" -) - -// BaseClient is the base client for Avs. -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, - } -} +// Package avs implements the Azure ARM Avs service API version 2020-03-20. +// +// Azure VMware Solution API +package avs + +// 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 Avs + DefaultBaseURI = "https://management.azure.com" +) + +// BaseClient is the base client for Avs. +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/avs/mgmt/2020-03-20/avs/clusters.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/clusters.go index fb28755b2d24..4db00f22bb14 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/clusters.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/clusters.go @@ -1,526 +1,523 @@ -package avs - -// 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" -) - -// ClustersClient is the azure VMware Solution API -type ClustersClient struct { - BaseClient -} - -// NewClustersClient creates an instance of the ClustersClient client. -func NewClustersClient(subscriptionID string) ClustersClient { - return NewClustersClientWithBaseURI(DefaultBaseURI, subscriptionID) -} - -// NewClustersClientWithBaseURI creates an instance of the ClustersClient 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 NewClustersClientWithBaseURI(baseURI string, subscriptionID string) ClustersClient { - return ClustersClient{NewWithBaseURI(baseURI, subscriptionID)} -} - -// CreateOrUpdate sends the create or update request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - the name of the private cloud. -// clusterName - name of the cluster in the private cloud -// cluster - a cluster in the private cloud -func (client ClustersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster Cluster) (result ClustersCreateOrUpdateFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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: cluster, - Constraints: []validation.Constraint{{Target: "cluster.Sku", Name: validation.Null, Rule: true, - Chain: []validation.Constraint{{Target: "cluster.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}, - {Target: "cluster.ClusterProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { - return result, validation.NewError("avs.ClustersClient", "CreateOrUpdate", err.Error()) - } - - req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, clusterName, cluster) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "CreateOrUpdate", nil, "Failure preparing request") - return - } - - result, err = client.CreateOrUpdateSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "CreateOrUpdate", result.Response(), "Failure sending request") - return - } - - return -} - -// CreateOrUpdatePreparer prepares the CreateOrUpdate request. -func (client ClustersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster Cluster) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "clusterName": autorest.Encode("path", clusterName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - 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.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", pathParameters), - autorest.WithJSON(cluster), - 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 ClustersClient) CreateOrUpdateSender(req *http.Request) (future ClustersCreateOrUpdateFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always -// closes the http.Response Body. -func (client ClustersClient) CreateOrUpdateResponder(resp *http.Response) (result Cluster, 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 sends the delete request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// clusterName - name of the cluster in the private cloud -func (client ClustersClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result ClustersDeleteFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.ClustersClient", "Delete", err.Error()) - } - - req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, clusterName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Delete", nil, "Failure preparing request") - return - } - - result, err = client.DeleteSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Delete", result.Response(), "Failure sending request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client ClustersClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "clusterName": autorest.Encode("path", clusterName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", 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 ClustersClient) DeleteSender(req *http.Request) (future ClustersDeleteFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client ClustersClient) 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 sends the get request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// clusterName - name of the cluster in the private cloud -func (client ClustersClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result Cluster, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.ClustersClient", "Get", err.Error()) - } - - req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, clusterName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", nil, "Failure preparing request") - return - } - - resp, err := client.GetSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", resp, "Failure sending request") - return - } - - result, err = client.GetResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", resp, "Failure responding to request") - } - - return -} - -// GetPreparer prepares the Get request. -func (client ClustersClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "clusterName": autorest.Encode("path", clusterName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", 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 ClustersClient) 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 ClustersClient) GetResponder(resp *http.Response) (result Cluster, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -// List sends the list request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -func (client ClustersClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result ClusterListPage, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.List") - defer func() { - sc := -1 - if result.cl.Response.Response != nil { - sc = result.cl.Response.Response.StatusCode - } - tracing.EndSpan(ctx, sc, err) - }() - } - if err := validation.Validate([]validation.Validation{ - {TargetValue: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.ClustersClient", "List", err.Error()) - } - - result.fn = client.listNextResults - req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", nil, "Failure preparing request") - return - } - - resp, err := client.ListSender(req) - if err != nil { - result.cl.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", resp, "Failure sending request") - return - } - - result.cl, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", resp, "Failure responding to request") - } - if result.cl.hasNextLink() && result.cl.IsEmpty() { - err = result.NextWithContext(ctx) - } - - return -} - -// ListPreparer prepares the List request. -func (client ClustersClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters", 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 ClustersClient) 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 ClustersClient) ListResponder(resp *http.Response) (result ClusterList, 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 ClustersClient) listNextResults(ctx context.Context, lastResults ClusterList) (result ClusterList, err error) { - req, err := lastResults.clusterListPreparer(ctx) - if err != nil { - return result, autorest.NewErrorWithError(err, "avs.ClustersClient", "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, "avs.ClustersClient", "listNextResults", resp, "Failure sending next results request") - } - result, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "listNextResults", resp, "Failure responding to next results request") - } - return -} - -// ListComplete enumerates all values, automatically crossing page boundaries as required. -func (client ClustersClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result ClusterListIterator, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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, privateCloudName) - return -} - -// Update sends the update request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// clusterName - name of the cluster in the private cloud -// clusterUpdate - the cluster properties to be updated -func (client ClustersClient) Update(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate ClusterUpdate) (result ClustersUpdateFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.ClustersClient", "Update", err.Error()) - } - - req, err := client.UpdatePreparer(ctx, resourceGroupName, privateCloudName, clusterName, clusterUpdate) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Update", nil, "Failure preparing request") - return - } - - result, err = client.UpdateSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Update", result.Response(), "Failure sending request") - return - } - - return -} - -// UpdatePreparer prepares the Update request. -func (client ClustersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate ClusterUpdate) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "clusterName": autorest.Encode("path", clusterName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - 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.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", pathParameters), - autorest.WithJSON(clusterUpdate), - 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 ClustersClient) UpdateSender(req *http.Request) (future ClustersUpdateFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// UpdateResponder handles the response to the Update request. The method always -// closes the http.Response Body. -func (client ClustersClient) UpdateResponder(resp *http.Response) (result Cluster, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} +package avs + +// 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" +) + +// ClustersClient is the azure VMware Solution API +type ClustersClient struct { + BaseClient +} + +// NewClustersClient creates an instance of the ClustersClient client. +func NewClustersClient(subscriptionID string) ClustersClient { + return NewClustersClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewClustersClientWithBaseURI creates an instance of the ClustersClient 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 NewClustersClientWithBaseURI(baseURI string, subscriptionID string) ClustersClient { + return ClustersClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - the name of the private cloud. +// clusterName - name of the cluster in the private cloud +// cluster - a cluster in the private cloud +func (client ClustersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster Cluster) (result ClustersCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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: cluster, + Constraints: []validation.Constraint{{Target: "cluster.Sku", Name: validation.Null, Rule: true, + Chain: []validation.Constraint{{Target: "cluster.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}, + {Target: "cluster.ClusterProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.ClustersClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, clusterName, cluster) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client ClustersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, cluster Cluster) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", pathParameters), + autorest.WithJSON(cluster), + 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 ClustersClient) CreateOrUpdateSender(req *http.Request) (future ClustersCreateOrUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client ClustersClient) CreateOrUpdateResponder(resp *http.Response) (result Cluster, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// clusterName - name of the cluster in the private cloud +func (client ClustersClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result ClustersDeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, clusterName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client ClustersClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", 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 ClustersClient) DeleteSender(req *http.Request) (future ClustersDeleteFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client ClustersClient) 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 sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// clusterName - name of the cluster in the private cloud +func (client ClustersClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (result Cluster, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, clusterName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client ClustersClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", 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 ClustersClient) 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 ClustersClient) GetResponder(resp *http.Response) (result Cluster, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client ClustersClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result ClusterListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.List") + defer func() { + sc := -1 + if result.cl.Response.Response != nil { + sc = result.cl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.cl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", resp, "Failure sending request") + return + } + + result.cl, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client ClustersClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/clusters", 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 ClustersClient) 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 ClustersClient) ListResponder(resp *http.Response) (result ClusterList, 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 ClustersClient) listNextResults(ctx context.Context, lastResults ClusterList) (result ClusterList, err error) { + req, err := lastResults.clusterListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.ClustersClient", "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, "avs.ClustersClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client ClustersClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result ClusterListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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, privateCloudName) + return +} + +// Update sends the update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// clusterName - name of the cluster in the private cloud +// clusterUpdate - the cluster properties to be updated +func (client ClustersClient) Update(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate ClusterUpdate) (result ClustersUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.ClustersClient", "Update", err.Error()) + } + + req, err := client.UpdatePreparer(ctx, resourceGroupName, privateCloudName, clusterName, clusterUpdate) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Update", nil, "Failure preparing request") + return + } + + result, err = client.UpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersClient", "Update", result.Response(), "Failure sending request") + return + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client ClustersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, clusterName string, clusterUpdate ClusterUpdate) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "clusterName": autorest.Encode("path", clusterName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/clusters/{clusterName}", pathParameters), + autorest.WithJSON(clusterUpdate), + 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 ClustersClient) UpdateSender(req *http.Request) (future ClustersUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client ClustersClient) UpdateResponder(resp *http.Response) (result Cluster, 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/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go index f04bbdee504f..06abda970182 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/hcxenterprisesites.go @@ -1,433 +1,430 @@ -package avs - -// 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" -) - -// HcxEnterpriseSitesClient is the azure VMware Solution API -type HcxEnterpriseSitesClient struct { - BaseClient -} - -// NewHcxEnterpriseSitesClient creates an instance of the HcxEnterpriseSitesClient client. -func NewHcxEnterpriseSitesClient(subscriptionID string) HcxEnterpriseSitesClient { - return NewHcxEnterpriseSitesClientWithBaseURI(DefaultBaseURI, subscriptionID) -} - -// NewHcxEnterpriseSitesClientWithBaseURI creates an instance of the HcxEnterpriseSitesClient 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 NewHcxEnterpriseSitesClientWithBaseURI(baseURI string, subscriptionID string) HcxEnterpriseSitesClient { - return HcxEnterpriseSitesClient{NewWithBaseURI(baseURI, subscriptionID)} -} - -// CreateOrUpdate sends the create or update request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - the name of the private cloud. -// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud -// hcxEnterpriseSite - the HCX Enterprise Site -func (client HcxEnterpriseSitesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (result HcxEnterpriseSite, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.CreateOrUpdate") - 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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.HcxEnterpriseSitesClient", "CreateOrUpdate", err.Error()) - } - - req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName, hcxEnterpriseSite) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", nil, "Failure preparing request") - return - } - - resp, err := client.CreateOrUpdateSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", resp, "Failure sending request") - return - } - - result, err = client.CreateOrUpdateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", resp, "Failure responding to request") - } - - return -} - -// CreateOrUpdatePreparer prepares the CreateOrUpdate request. -func (client HcxEnterpriseSitesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - 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.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", pathParameters), - autorest.WithJSON(hcxEnterpriseSite), - 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) CreateOrUpdateResponder(resp *http.Response) (result HcxEnterpriseSite, 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 sends the delete request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud -func (client HcxEnterpriseSitesClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result autorest.Response, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.HcxEnterpriseSitesClient", "Delete", err.Error()) - } - - req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result.Response = resp - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", resp, "Failure responding to request") - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client HcxEnterpriseSitesClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) 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 -} - -// Get sends the get request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud -func (client HcxEnterpriseSitesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result HcxEnterpriseSite, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.HcxEnterpriseSitesClient", "Get", err.Error()) - } - - req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", nil, "Failure preparing request") - return - } - - resp, err := client.GetSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", resp, "Failure sending request") - return - } - - result, err = client.GetResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", resp, "Failure responding to request") - } - - return -} - -// GetPreparer prepares the Get request. -func (client HcxEnterpriseSitesClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) GetResponder(resp *http.Response) (result HcxEnterpriseSite, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -// List sends the list request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -func (client HcxEnterpriseSitesClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result HcxEnterpriseSiteListPage, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.List") - defer func() { - sc := -1 - if result.hesl.Response.Response != nil { - sc = result.hesl.Response.Response.StatusCode - } - tracing.EndSpan(ctx, sc, err) - }() - } - if err := validation.Validate([]validation.Validation{ - {TargetValue: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.HcxEnterpriseSitesClient", "List", err.Error()) - } - - result.fn = client.listNextResults - req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", nil, "Failure preparing request") - return - } - - resp, err := client.ListSender(req) - if err != nil { - result.hesl.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", resp, "Failure sending request") - return - } - - result.hesl, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", resp, "Failure responding to request") - } - if result.hesl.hasNextLink() && result.hesl.IsEmpty() { - err = result.NextWithContext(ctx) - } - - return -} - -// ListPreparer prepares the List request. -func (client HcxEnterpriseSitesClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) ListResponder(resp *http.Response) (result HcxEnterpriseSiteList, 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 HcxEnterpriseSitesClient) listNextResults(ctx context.Context, lastResults HcxEnterpriseSiteList) (result HcxEnterpriseSiteList, err error) { - req, err := lastResults.hcxEnterpriseSiteListPreparer(ctx) - if err != nil { - return result, autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "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, "avs.HcxEnterpriseSitesClient", "listNextResults", resp, "Failure sending next results request") - } - result, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "listNextResults", resp, "Failure responding to next results request") - } - return -} - -// ListComplete enumerates all values, automatically crossing page boundaries as required. -func (client HcxEnterpriseSitesClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result HcxEnterpriseSiteListIterator, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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, privateCloudName) - return -} +package avs + +// 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" +) + +// HcxEnterpriseSitesClient is the azure VMware Solution API +type HcxEnterpriseSitesClient struct { + BaseClient +} + +// NewHcxEnterpriseSitesClient creates an instance of the HcxEnterpriseSitesClient client. +func NewHcxEnterpriseSitesClient(subscriptionID string) HcxEnterpriseSitesClient { + return NewHcxEnterpriseSitesClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewHcxEnterpriseSitesClientWithBaseURI creates an instance of the HcxEnterpriseSitesClient 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 NewHcxEnterpriseSitesClientWithBaseURI(baseURI string, subscriptionID string) HcxEnterpriseSitesClient { + return HcxEnterpriseSitesClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - the name of the private cloud. +// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud +// hcxEnterpriseSite - the HCX Enterprise Site +func (client HcxEnterpriseSitesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (result HcxEnterpriseSite, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.CreateOrUpdate") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName, hcxEnterpriseSite) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + resp, err := client.CreateOrUpdateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", resp, "Failure sending request") + return + } + + result, err = client.CreateOrUpdateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "CreateOrUpdate", resp, "Failure responding to request") + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client HcxEnterpriseSitesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string, hcxEnterpriseSite interface{}) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", pathParameters), + autorest.WithJSON(hcxEnterpriseSite), + 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) CreateOrUpdateResponder(resp *http.Response) (result HcxEnterpriseSite, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud +func (client HcxEnterpriseSitesClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Delete", resp, "Failure responding to request") + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client HcxEnterpriseSitesClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) 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 +} + +// Get sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// hcxEnterpriseSiteName - name of the HCX Enterprise Site in the private cloud +func (client HcxEnterpriseSitesClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (result HcxEnterpriseSite, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName, hcxEnterpriseSiteName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client HcxEnterpriseSitesClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string, hcxEnterpriseSiteName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "hcxEnterpriseSiteName": autorest.Encode("path", hcxEnterpriseSiteName), + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites/{hcxEnterpriseSiteName}", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) GetResponder(resp *http.Response) (result HcxEnterpriseSite, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client HcxEnterpriseSitesClient) List(ctx context.Context, resourceGroupName string, privateCloudName string) (result HcxEnterpriseSiteListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.List") + defer func() { + sc := -1 + if result.hesl.Response.Response != nil { + sc = result.hesl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.HcxEnterpriseSitesClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.hesl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", resp, "Failure sending request") + return + } + + result.hesl, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client HcxEnterpriseSitesClient) ListPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/hcxEnterpriseSites", 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 HcxEnterpriseSitesClient) 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 HcxEnterpriseSitesClient) ListResponder(resp *http.Response) (result HcxEnterpriseSiteList, 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 HcxEnterpriseSitesClient) listNextResults(ctx context.Context, lastResults HcxEnterpriseSiteList) (result HcxEnterpriseSiteList, err error) { + req, err := lastResults.hcxEnterpriseSiteListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "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, "avs.HcxEnterpriseSitesClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.HcxEnterpriseSitesClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client HcxEnterpriseSitesClient) ListComplete(ctx context.Context, resourceGroupName string, privateCloudName string) (result HcxEnterpriseSiteListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSitesClient.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, privateCloudName) + return +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go index 1a3f5032a634..27fa5caec5ff 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/locations.go @@ -1,201 +1,201 @@ -package avs - -// 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" -) - -// LocationsClient is the azure VMware Solution API -type LocationsClient struct { - BaseClient -} - -// NewLocationsClient creates an instance of the LocationsClient client. -func NewLocationsClient(subscriptionID string) LocationsClient { - return NewLocationsClientWithBaseURI(DefaultBaseURI, subscriptionID) -} - -// NewLocationsClientWithBaseURI creates an instance of the LocationsClient 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 NewLocationsClientWithBaseURI(baseURI string, subscriptionID string) LocationsClient { - return LocationsClient{NewWithBaseURI(baseURI, subscriptionID)} -} - -// CheckQuotaAvailability return quota for subscription by region -// Parameters: -// location - azure region -func (client LocationsClient) CheckQuotaAvailability(ctx context.Context, location string) (result Quota, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/LocationsClient.CheckQuotaAvailability") - 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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { - return result, validation.NewError("avs.LocationsClient", "CheckQuotaAvailability", err.Error()) - } - - req, err := client.CheckQuotaAvailabilityPreparer(ctx, location) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", nil, "Failure preparing request") - return - } - - resp, err := client.CheckQuotaAvailabilitySender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", resp, "Failure sending request") - return - } - - result, err = client.CheckQuotaAvailabilityResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", resp, "Failure responding to request") - } - - return -} - -// CheckQuotaAvailabilityPreparer prepares the CheckQuotaAvailability request. -func (client LocationsClient) CheckQuotaAvailabilityPreparer(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 = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsPost(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/locations/{location}/checkQuotaAvailability", pathParameters), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// CheckQuotaAvailabilitySender sends the CheckQuotaAvailability request. The method will close the -// http.Response Body if it receives an error. -func (client LocationsClient) CheckQuotaAvailabilitySender(req *http.Request) (*http.Response, error) { - return client.Send(req, azure.DoRetryWithRegistration(client.Client)) -} - -// CheckQuotaAvailabilityResponder handles the response to the CheckQuotaAvailability request. The method always -// closes the http.Response Body. -func (client LocationsClient) CheckQuotaAvailabilityResponder(resp *http.Response) (result Quota, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -// CheckTrialAvailability return trial status for subscription by region -// Parameters: -// location - azure region -func (client LocationsClient) CheckTrialAvailability(ctx context.Context, location string) (result Trial, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/LocationsClient.CheckTrialAvailability") - 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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { - return result, validation.NewError("avs.LocationsClient", "CheckTrialAvailability", err.Error()) - } - - req, err := client.CheckTrialAvailabilityPreparer(ctx, location) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", nil, "Failure preparing request") - return - } - - resp, err := client.CheckTrialAvailabilitySender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", resp, "Failure sending request") - return - } - - result, err = client.CheckTrialAvailabilityResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", resp, "Failure responding to request") - } - - return -} - -// CheckTrialAvailabilityPreparer prepares the CheckTrialAvailability request. -func (client LocationsClient) CheckTrialAvailabilityPreparer(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 = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsPost(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/locations/{location}/checkTrialAvailability", pathParameters), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// CheckTrialAvailabilitySender sends the CheckTrialAvailability request. The method will close the -// http.Response Body if it receives an error. -func (client LocationsClient) CheckTrialAvailabilitySender(req *http.Request) (*http.Response, error) { - return client.Send(req, azure.DoRetryWithRegistration(client.Client)) -} - -// CheckTrialAvailabilityResponder handles the response to the CheckTrialAvailability request. The method always -// closes the http.Response Body. -func (client LocationsClient) CheckTrialAvailabilityResponder(resp *http.Response) (result Trial, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} +package avs + +// 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" +) + +// LocationsClient is the azure VMware Solution API +type LocationsClient struct { + BaseClient +} + +// NewLocationsClient creates an instance of the LocationsClient client. +func NewLocationsClient(subscriptionID string) LocationsClient { + return NewLocationsClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewLocationsClientWithBaseURI creates an instance of the LocationsClient 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 NewLocationsClientWithBaseURI(baseURI string, subscriptionID string) LocationsClient { + return LocationsClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CheckQuotaAvailability return quota for subscription by region +// Parameters: +// location - azure region +func (client LocationsClient) CheckQuotaAvailability(ctx context.Context, location string) (result Quota, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LocationsClient.CheckQuotaAvailability") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.LocationsClient", "CheckQuotaAvailability", err.Error()) + } + + req, err := client.CheckQuotaAvailabilityPreparer(ctx, location) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", nil, "Failure preparing request") + return + } + + resp, err := client.CheckQuotaAvailabilitySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", resp, "Failure sending request") + return + } + + result, err = client.CheckQuotaAvailabilityResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckQuotaAvailability", resp, "Failure responding to request") + } + + return +} + +// CheckQuotaAvailabilityPreparer prepares the CheckQuotaAvailability request. +func (client LocationsClient) CheckQuotaAvailabilityPreparer(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 = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/locations/{location}/checkQuotaAvailability", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CheckQuotaAvailabilitySender sends the CheckQuotaAvailability request. The method will close the +// http.Response Body if it receives an error. +func (client LocationsClient) CheckQuotaAvailabilitySender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// CheckQuotaAvailabilityResponder handles the response to the CheckQuotaAvailability request. The method always +// closes the http.Response Body. +func (client LocationsClient) CheckQuotaAvailabilityResponder(resp *http.Response) (result Quota, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// CheckTrialAvailability return trial status for subscription by region +// Parameters: +// location - azure region +func (client LocationsClient) CheckTrialAvailability(ctx context.Context, location string) (result Trial, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/LocationsClient.CheckTrialAvailability") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.LocationsClient", "CheckTrialAvailability", err.Error()) + } + + req, err := client.CheckTrialAvailabilityPreparer(ctx, location) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", nil, "Failure preparing request") + return + } + + resp, err := client.CheckTrialAvailabilitySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", resp, "Failure sending request") + return + } + + result, err = client.CheckTrialAvailabilityResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.LocationsClient", "CheckTrialAvailability", resp, "Failure responding to request") + } + + return +} + +// CheckTrialAvailabilityPreparer prepares the CheckTrialAvailability request. +func (client LocationsClient) CheckTrialAvailabilityPreparer(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 = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/locations/{location}/checkTrialAvailability", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CheckTrialAvailabilitySender sends the CheckTrialAvailability request. The method will close the +// http.Response Body if it receives an error. +func (client LocationsClient) CheckTrialAvailabilitySender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// CheckTrialAvailabilityResponder handles the response to the CheckTrialAvailability request. The method always +// closes the http.Response Body. +func (client LocationsClient) CheckTrialAvailabilityResponder(resp *http.Response) (result Trial, 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/avs/mgmt/2020-03-20/avs/models.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/models.go index 26c10c261f3a..ab5b813b1640 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/models.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/models.go @@ -1,1770 +1,1822 @@ -package avs - -// 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/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/avs/mgmt/2020-03-20/avs" - -// AdminCredentials administrative credentials for accessing vCenter and NSX-T -type AdminCredentials struct { - autorest.Response `json:"-"` - // NsxtUsername - READ-ONLY; NSX-T Manager username - NsxtUsername *string `json:"nsxtUsername,omitempty"` - // NsxtPassword - READ-ONLY; NSX-T Manager password - NsxtPassword *string `json:"nsxtPassword,omitempty"` - // VcenterUsername - READ-ONLY; vCenter admin username - VcenterUsername *string `json:"vcenterUsername,omitempty"` - // VcenterPassword - READ-ONLY; vCenter admin password - VcenterPassword *string `json:"vcenterPassword,omitempty"` -} - -// AuthorizationsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a -// long-running operation. -type AuthorizationsCreateOrUpdateFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *AuthorizationsCreateOrUpdateFuture) Result(client AuthorizationsClient) (era ExpressRouteAuthorization, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.AuthorizationsCreateOrUpdateFuture") - return - } - sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) - if era.Response.Response, err = future.GetResult(sender); err == nil && era.Response.Response.StatusCode != http.StatusNoContent { - era, err = client.CreateOrUpdateResponder(era.Response.Response) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsCreateOrUpdateFuture", "Result", era.Response.Response, "Failure responding to request") - } - } - return -} - -// AuthorizationsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. -type AuthorizationsDeleteFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *AuthorizationsDeleteFuture) Result(client AuthorizationsClient) (ar autorest.Response, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.AuthorizationsDeleteFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.AuthorizationsDeleteFuture") - return - } - ar.Response = future.Response() - return -} - -// Circuit an ExpressRoute Circuit -type Circuit struct { - // PrimarySubnet - READ-ONLY; CIDR of primary subnet - PrimarySubnet *string `json:"primarySubnet,omitempty"` - // SecondarySubnet - READ-ONLY; CIDR of secondary subnet - SecondarySubnet *string `json:"secondarySubnet,omitempty"` - // ExpressRouteID - READ-ONLY; Identifier of the ExpressRoute Circuit (Microsoft Colo only) - ExpressRouteID *string `json:"expressRouteID,omitempty"` - // ExpressRoutePrivatePeeringID - READ-ONLY; ExpressRoute Circuit private peering identifier - ExpressRoutePrivatePeeringID *string `json:"expressRoutePrivatePeeringID,omitempty"` -} - -// CloudError API error response -type CloudError struct { - // Error - An error returned by the API - Error *ErrorResponse `json:"error,omitempty"` -} - -// Cluster a cluster resource -type Cluster struct { - autorest.Response `json:"-"` - // Sku - The cluster SKU - Sku *Sku `json:"sku,omitempty"` - // ClusterProperties - The properties of a cluster resource - *ClusterProperties `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"` -} - -// MarshalJSON is the custom marshaler for Cluster. -func (c Cluster) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if c.Sku != nil { - objectMap["sku"] = c.Sku - } - if c.ClusterProperties != nil { - objectMap["properties"] = c.ClusterProperties - } - return json.Marshal(objectMap) -} - -// UnmarshalJSON is the custom unmarshaler for Cluster struct. -func (c *Cluster) 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 - } - c.Sku = &sku - } - case "properties": - if v != nil { - var clusterProperties ClusterProperties - err = json.Unmarshal(*v, &clusterProperties) - if err != nil { - return err - } - c.ClusterProperties = &clusterProperties - } - case "id": - if v != nil { - var ID string - err = json.Unmarshal(*v, &ID) - if err != nil { - return err - } - c.ID = &ID - } - case "name": - if v != nil { - var name string - err = json.Unmarshal(*v, &name) - if err != nil { - return err - } - c.Name = &name - } - case "type": - if v != nil { - var typeVar string - err = json.Unmarshal(*v, &typeVar) - if err != nil { - return err - } - c.Type = &typeVar - } - } - } - - return nil -} - -// ClusterList a paged list of clusters -type ClusterList struct { - autorest.Response `json:"-"` - // Value - READ-ONLY; The items on a page - Value *[]Cluster `json:"value,omitempty"` - // NextLink - READ-ONLY; URL to get the next page if any - NextLink *string `json:"nextLink,omitempty"` -} - -// ClusterListIterator provides access to a complete listing of Cluster values. -type ClusterListIterator struct { - i int - page ClusterListPage -} - -// 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 *ClusterListIterator) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClusterListIterator.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 *ClusterListIterator) Next() error { - return iter.NextWithContext(context.Background()) -} - -// NotDone returns true if the enumeration should be started or is not yet complete. -func (iter ClusterListIterator) 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 ClusterListIterator) Response() ClusterList { - 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 ClusterListIterator) Value() Cluster { - if !iter.page.NotDone() { - return Cluster{} - } - return iter.page.Values()[iter.i] -} - -// Creates a new instance of the ClusterListIterator type. -func NewClusterListIterator(page ClusterListPage) ClusterListIterator { - return ClusterListIterator{page: page} -} - -// IsEmpty returns true if the ListResult contains no values. -func (cl ClusterList) IsEmpty() bool { - return cl.Value == nil || len(*cl.Value) == 0 -} - -// hasNextLink returns true if the NextLink is not empty. -func (cl ClusterList) hasNextLink() bool { - return cl.NextLink != nil && len(*cl.NextLink) != 0 -} - -// clusterListPreparer prepares a request to retrieve the next set of results. -// It returns nil if no more results exist. -func (cl ClusterList) clusterListPreparer(ctx context.Context) (*http.Request, error) { - if !cl.hasNextLink() { - return nil, nil - } - return autorest.Prepare((&http.Request{}).WithContext(ctx), - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(cl.NextLink))) -} - -// ClusterListPage contains a page of Cluster values. -type ClusterListPage struct { - fn func(context.Context, ClusterList) (ClusterList, error) - cl ClusterList -} - -// 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 *ClusterListPage) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ClusterListPage.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.cl) - if err != nil { - return err - } - page.cl = 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 *ClusterListPage) Next() error { - return page.NextWithContext(context.Background()) -} - -// NotDone returns true if the page enumeration should be started or is not yet complete. -func (page ClusterListPage) NotDone() bool { - return !page.cl.IsEmpty() -} - -// Response returns the raw server response from the last page request. -func (page ClusterListPage) Response() ClusterList { - return page.cl -} - -// Values returns the slice of values for the current page or nil if there are no values. -func (page ClusterListPage) Values() []Cluster { - if page.cl.IsEmpty() { - return nil - } - return *page.cl.Value -} - -// Creates a new instance of the ClusterListPage type. -func NewClusterListPage(getNextPage func(context.Context, ClusterList) (ClusterList, error)) ClusterListPage { - return ClusterListPage{fn: getNextPage} -} - -// ClusterProperties the properties of a cluster -type ClusterProperties struct { - // ProvisioningState - READ-ONLY; The state of the cluster provisioning. Possible values include: 'Succeeded', 'Failed', 'Cancelled', 'Deleting', 'Updating' - ProvisioningState ClusterProvisioningState `json:"provisioningState,omitempty"` - // ClusterID - READ-ONLY; The identity - ClusterID *int32 `json:"clusterId,omitempty"` - // Hosts - READ-ONLY; The hosts - Hosts *[]string `json:"hosts,omitempty"` - // ClusterSize - The cluster size - ClusterSize *int32 `json:"clusterSize,omitempty"` -} - -// MarshalJSON is the custom marshaler for ClusterProperties. -func (cp ClusterProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if cp.ClusterSize != nil { - objectMap["clusterSize"] = cp.ClusterSize - } - return json.Marshal(objectMap) -} - -// ClustersCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. -type ClustersCreateOrUpdateFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *ClustersCreateOrUpdateFuture) Result(client ClustersClient) (c Cluster, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.ClustersCreateOrUpdateFuture") - return - } - sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) - if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { - c, err = client.CreateOrUpdateResponder(c.Response.Response) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersCreateOrUpdateFuture", "Result", c.Response.Response, "Failure responding to request") - } - } - return -} - -// ClustersDeleteFuture an abstraction for monitoring and retrieving the results of a long-running operation. -type ClustersDeleteFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *ClustersDeleteFuture) Result(client ClustersClient) (ar autorest.Response, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersDeleteFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.ClustersDeleteFuture") - return - } - ar.Response = future.Response() - return -} - -// ClustersUpdateFuture an abstraction for monitoring and retrieving the results of a long-running operation. -type ClustersUpdateFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *ClustersUpdateFuture) Result(client ClustersClient) (c Cluster, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersUpdateFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.ClustersUpdateFuture") - return - } - sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) - if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { - c, err = client.UpdateResponder(c.Response.Response) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.ClustersUpdateFuture", "Result", c.Response.Response, "Failure responding to request") - } - } - return -} - -// ClusterUpdate an update of a cluster resource -type ClusterUpdate struct { - // ClusterUpdateProperties - The properties of a cluster resource that may be updated - *ClusterUpdateProperties `json:"properties,omitempty"` -} - -// MarshalJSON is the custom marshaler for ClusterUpdate. -func (cu ClusterUpdate) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if cu.ClusterUpdateProperties != nil { - objectMap["properties"] = cu.ClusterUpdateProperties - } - return json.Marshal(objectMap) -} - -// UnmarshalJSON is the custom unmarshaler for ClusterUpdate struct. -func (cu *ClusterUpdate) 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 clusterUpdateProperties ClusterUpdateProperties - err = json.Unmarshal(*v, &clusterUpdateProperties) - if err != nil { - return err - } - cu.ClusterUpdateProperties = &clusterUpdateProperties - } - } - } - - return nil -} - -// ClusterUpdateProperties the properties of a cluster that may be updated -type ClusterUpdateProperties struct { - // ClusterSize - The cluster size - ClusterSize *int32 `json:"clusterSize,omitempty"` -} - -// Endpoints endpoint addresses -type Endpoints struct { - // NsxtManager - READ-ONLY; Endpoint for the NSX-T Data Center manager - NsxtManager *string `json:"nsxtManager,omitempty"` - // Vcsa - READ-ONLY; Endpoint for Virtual Center Server Appliance - Vcsa *string `json:"vcsa,omitempty"` - // HcxCloudManager - READ-ONLY; Endpoint for the HCX Cloud Manager - HcxCloudManager *string `json:"hcxCloudManager,omitempty"` -} - -// ErrorAdditionalInfo the resource management error additional info. -type ErrorAdditionalInfo struct { - // Type - READ-ONLY; The additional info type. - Type *string `json:"type,omitempty"` - // Info - READ-ONLY; The additional info. - Info interface{} `json:"info,omitempty"` -} - -// ErrorResponse the resource management error response. -type ErrorResponse struct { - // Code - READ-ONLY; The error code. - Code *string `json:"code,omitempty"` - // Message - READ-ONLY; The error message. - Message *string `json:"message,omitempty"` - // Target - READ-ONLY; The error target. - Target *string `json:"target,omitempty"` - // Details - READ-ONLY; The error details. - Details *[]ErrorResponse `json:"details,omitempty"` - // AdditionalInfo - READ-ONLY; The error additional info. - AdditionalInfo *[]ErrorAdditionalInfo `json:"additionalInfo,omitempty"` -} - -// ExpressRouteAuthorization expressRoute Circuit Authorization -type ExpressRouteAuthorization struct { - autorest.Response `json:"-"` - // ExpressRouteAuthorizationProperties - The properties of an ExpressRoute Circuit Authorization resource - *ExpressRouteAuthorizationProperties `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"` -} - -// MarshalJSON is the custom marshaler for ExpressRouteAuthorization. -func (era ExpressRouteAuthorization) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if era.ExpressRouteAuthorizationProperties != nil { - objectMap["properties"] = era.ExpressRouteAuthorizationProperties - } - return json.Marshal(objectMap) -} - -// UnmarshalJSON is the custom unmarshaler for ExpressRouteAuthorization struct. -func (era *ExpressRouteAuthorization) 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 expressRouteAuthorizationProperties ExpressRouteAuthorizationProperties - err = json.Unmarshal(*v, &expressRouteAuthorizationProperties) - if err != nil { - return err - } - era.ExpressRouteAuthorizationProperties = &expressRouteAuthorizationProperties - } - case "id": - if v != nil { - var ID string - err = json.Unmarshal(*v, &ID) - if err != nil { - return err - } - era.ID = &ID - } - case "name": - if v != nil { - var name string - err = json.Unmarshal(*v, &name) - if err != nil { - return err - } - era.Name = &name - } - case "type": - if v != nil { - var typeVar string - err = json.Unmarshal(*v, &typeVar) - if err != nil { - return err - } - era.Type = &typeVar - } - } - } - - return nil -} - -// ExpressRouteAuthorizationList a paged list of ExpressRoute Circuit Authorizations -type ExpressRouteAuthorizationList struct { - autorest.Response `json:"-"` - // Value - READ-ONLY; The items on a page - Value *[]ExpressRouteAuthorization `json:"value,omitempty"` - // NextLink - READ-ONLY; URL to get the next page if any - NextLink *string `json:"nextLink,omitempty"` -} - -// ExpressRouteAuthorizationListIterator provides access to a complete listing of ExpressRouteAuthorization -// values. -type ExpressRouteAuthorizationListIterator struct { - i int - page ExpressRouteAuthorizationListPage -} - -// 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 *ExpressRouteAuthorizationListIterator) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteAuthorizationListIterator.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 *ExpressRouteAuthorizationListIterator) Next() error { - return iter.NextWithContext(context.Background()) -} - -// NotDone returns true if the enumeration should be started or is not yet complete. -func (iter ExpressRouteAuthorizationListIterator) 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 ExpressRouteAuthorizationListIterator) Response() ExpressRouteAuthorizationList { - 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 ExpressRouteAuthorizationListIterator) Value() ExpressRouteAuthorization { - if !iter.page.NotDone() { - return ExpressRouteAuthorization{} - } - return iter.page.Values()[iter.i] -} - -// Creates a new instance of the ExpressRouteAuthorizationListIterator type. -func NewExpressRouteAuthorizationListIterator(page ExpressRouteAuthorizationListPage) ExpressRouteAuthorizationListIterator { - return ExpressRouteAuthorizationListIterator{page: page} -} - -// IsEmpty returns true if the ListResult contains no values. -func (eral ExpressRouteAuthorizationList) IsEmpty() bool { - return eral.Value == nil || len(*eral.Value) == 0 -} - -// hasNextLink returns true if the NextLink is not empty. -func (eral ExpressRouteAuthorizationList) hasNextLink() bool { - return eral.NextLink != nil && len(*eral.NextLink) != 0 -} - -// expressRouteAuthorizationListPreparer prepares a request to retrieve the next set of results. -// It returns nil if no more results exist. -func (eral ExpressRouteAuthorizationList) expressRouteAuthorizationListPreparer(ctx context.Context) (*http.Request, error) { - if !eral.hasNextLink() { - return nil, nil - } - return autorest.Prepare((&http.Request{}).WithContext(ctx), - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(eral.NextLink))) -} - -// ExpressRouteAuthorizationListPage contains a page of ExpressRouteAuthorization values. -type ExpressRouteAuthorizationListPage struct { - fn func(context.Context, ExpressRouteAuthorizationList) (ExpressRouteAuthorizationList, error) - eral ExpressRouteAuthorizationList -} - -// 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 *ExpressRouteAuthorizationListPage) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteAuthorizationListPage.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.eral) - if err != nil { - return err - } - page.eral = 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 *ExpressRouteAuthorizationListPage) Next() error { - return page.NextWithContext(context.Background()) -} - -// NotDone returns true if the page enumeration should be started or is not yet complete. -func (page ExpressRouteAuthorizationListPage) NotDone() bool { - return !page.eral.IsEmpty() -} - -// Response returns the raw server response from the last page request. -func (page ExpressRouteAuthorizationListPage) Response() ExpressRouteAuthorizationList { - return page.eral -} - -// Values returns the slice of values for the current page or nil if there are no values. -func (page ExpressRouteAuthorizationListPage) Values() []ExpressRouteAuthorization { - if page.eral.IsEmpty() { - return nil - } - return *page.eral.Value -} - -// Creates a new instance of the ExpressRouteAuthorizationListPage type. -func NewExpressRouteAuthorizationListPage(getNextPage func(context.Context, ExpressRouteAuthorizationList) (ExpressRouteAuthorizationList, error)) ExpressRouteAuthorizationListPage { - return ExpressRouteAuthorizationListPage{fn: getNextPage} -} - -// ExpressRouteAuthorizationProperties the properties of an ExpressRoute Circuit Authorization resource -type ExpressRouteAuthorizationProperties struct { - // ProvisioningState - READ-ONLY; The state of the ExpressRoute Circuit Authorization provisioning. Possible values include: 'ExpressRouteAuthorizationProvisioningStateSucceeded', 'ExpressRouteAuthorizationProvisioningStateFailed', 'ExpressRouteAuthorizationProvisioningStateUpdating' - ProvisioningState ExpressRouteAuthorizationProvisioningState `json:"provisioningState,omitempty"` - // ExpressRouteAuthorizationID - READ-ONLY; The ID of the ExpressRoute Circuit Authorization - ExpressRouteAuthorizationID *string `json:"expressRouteAuthorizationId,omitempty"` - // ExpressRouteAuthorizationKey - READ-ONLY; The key of the ExpressRoute Circuit Authorization - ExpressRouteAuthorizationKey *string `json:"expressRouteAuthorizationKey,omitempty"` -} - -// HcxEnterpriseSite an HCX Enterprise Site resource -type HcxEnterpriseSite struct { - autorest.Response `json:"-"` - // HcxEnterpriseSiteProperties - The properties of an HCX Enterprise Site resource - *HcxEnterpriseSiteProperties `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"` -} - -// MarshalJSON is the custom marshaler for HcxEnterpriseSite. -func (hes HcxEnterpriseSite) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if hes.HcxEnterpriseSiteProperties != nil { - objectMap["properties"] = hes.HcxEnterpriseSiteProperties - } - return json.Marshal(objectMap) -} - -// UnmarshalJSON is the custom unmarshaler for HcxEnterpriseSite struct. -func (hes *HcxEnterpriseSite) 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 hcxEnterpriseSiteProperties HcxEnterpriseSiteProperties - err = json.Unmarshal(*v, &hcxEnterpriseSiteProperties) - if err != nil { - return err - } - hes.HcxEnterpriseSiteProperties = &hcxEnterpriseSiteProperties - } - case "id": - if v != nil { - var ID string - err = json.Unmarshal(*v, &ID) - if err != nil { - return err - } - hes.ID = &ID - } - case "name": - if v != nil { - var name string - err = json.Unmarshal(*v, &name) - if err != nil { - return err - } - hes.Name = &name - } - case "type": - if v != nil { - var typeVar string - err = json.Unmarshal(*v, &typeVar) - if err != nil { - return err - } - hes.Type = &typeVar - } - } - } - - return nil -} - -// HcxEnterpriseSiteList a paged list of HCX Enterprise Sites -type HcxEnterpriseSiteList struct { - autorest.Response `json:"-"` - // Value - READ-ONLY; The items on a page - Value *[]HcxEnterpriseSite `json:"value,omitempty"` - // NextLink - READ-ONLY; URL to get the next page if any - NextLink *string `json:"nextLink,omitempty"` -} - -// HcxEnterpriseSiteListIterator provides access to a complete listing of HcxEnterpriseSite values. -type HcxEnterpriseSiteListIterator struct { - i int - page HcxEnterpriseSiteListPage -} - -// 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 *HcxEnterpriseSiteListIterator) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSiteListIterator.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 *HcxEnterpriseSiteListIterator) Next() error { - return iter.NextWithContext(context.Background()) -} - -// NotDone returns true if the enumeration should be started or is not yet complete. -func (iter HcxEnterpriseSiteListIterator) 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 HcxEnterpriseSiteListIterator) Response() HcxEnterpriseSiteList { - 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 HcxEnterpriseSiteListIterator) Value() HcxEnterpriseSite { - if !iter.page.NotDone() { - return HcxEnterpriseSite{} - } - return iter.page.Values()[iter.i] -} - -// Creates a new instance of the HcxEnterpriseSiteListIterator type. -func NewHcxEnterpriseSiteListIterator(page HcxEnterpriseSiteListPage) HcxEnterpriseSiteListIterator { - return HcxEnterpriseSiteListIterator{page: page} -} - -// IsEmpty returns true if the ListResult contains no values. -func (hesl HcxEnterpriseSiteList) IsEmpty() bool { - return hesl.Value == nil || len(*hesl.Value) == 0 -} - -// hasNextLink returns true if the NextLink is not empty. -func (hesl HcxEnterpriseSiteList) hasNextLink() bool { - return hesl.NextLink != nil && len(*hesl.NextLink) != 0 -} - -// hcxEnterpriseSiteListPreparer prepares a request to retrieve the next set of results. -// It returns nil if no more results exist. -func (hesl HcxEnterpriseSiteList) hcxEnterpriseSiteListPreparer(ctx context.Context) (*http.Request, error) { - if !hesl.hasNextLink() { - return nil, nil - } - return autorest.Prepare((&http.Request{}).WithContext(ctx), - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(hesl.NextLink))) -} - -// HcxEnterpriseSiteListPage contains a page of HcxEnterpriseSite values. -type HcxEnterpriseSiteListPage struct { - fn func(context.Context, HcxEnterpriseSiteList) (HcxEnterpriseSiteList, error) - hesl HcxEnterpriseSiteList -} - -// 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 *HcxEnterpriseSiteListPage) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSiteListPage.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.hesl) - if err != nil { - return err - } - page.hesl = 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 *HcxEnterpriseSiteListPage) Next() error { - return page.NextWithContext(context.Background()) -} - -// NotDone returns true if the page enumeration should be started or is not yet complete. -func (page HcxEnterpriseSiteListPage) NotDone() bool { - return !page.hesl.IsEmpty() -} - -// Response returns the raw server response from the last page request. -func (page HcxEnterpriseSiteListPage) Response() HcxEnterpriseSiteList { - return page.hesl -} - -// Values returns the slice of values for the current page or nil if there are no values. -func (page HcxEnterpriseSiteListPage) Values() []HcxEnterpriseSite { - if page.hesl.IsEmpty() { - return nil - } - return *page.hesl.Value -} - -// Creates a new instance of the HcxEnterpriseSiteListPage type. -func NewHcxEnterpriseSiteListPage(getNextPage func(context.Context, HcxEnterpriseSiteList) (HcxEnterpriseSiteList, error)) HcxEnterpriseSiteListPage { - return HcxEnterpriseSiteListPage{fn: getNextPage} -} - -// HcxEnterpriseSiteProperties the properties of an HCX Enterprise Site -type HcxEnterpriseSiteProperties struct { - // ActivationKey - READ-ONLY; The activation key - ActivationKey *string `json:"activationKey,omitempty"` - // Status - READ-ONLY; The status of the HCX Enterprise Site. Possible values include: 'Available', 'Consumed', 'Deactivated', 'Deleted' - Status HcxEnterpriseSiteStatus `json:"status,omitempty"` -} - -// IdentitySource vCenter Single Sign On Identity Source -type IdentitySource struct { - // Name - The name of the identity source - Name *string `json:"name,omitempty"` - // Alias - The domain's NetBIOS name - Alias *string `json:"alias,omitempty"` - // Domain - The domain's dns name - Domain *string `json:"domain,omitempty"` - // BaseUserDN - The base distinguished name for users - BaseUserDN *string `json:"baseUserDN,omitempty"` - // BaseGroupDN - The base distinguished name for groups - BaseGroupDN *string `json:"baseGroupDN,omitempty"` - // PrimaryServer - Primary server URL - PrimaryServer *string `json:"primaryServer,omitempty"` - // SecondaryServer - Secondary server URL - SecondaryServer *string `json:"secondaryServer,omitempty"` - // Ssl - Protect LDAP communication using SSL certificate (LDAPS). Possible values include: 'SslEnumEnabled', 'SslEnumDisabled' - Ssl SslEnum `json:"ssl,omitempty"` - // Username - The ID of an Active Directory user with a minimum of read-only access to Base DN for users and group - Username *string `json:"username,omitempty"` - // Password - The password of the Active Directory user with a minimum of read-only access to Base DN for users and groups. - Password *string `json:"password,omitempty"` -} - -// ManagementCluster the properties of a default cluster -type ManagementCluster struct { - // ClusterID - READ-ONLY; The identity - ClusterID *int32 `json:"clusterId,omitempty"` - // Hosts - READ-ONLY; The hosts - Hosts *[]string `json:"hosts,omitempty"` - // ClusterSize - The cluster size - ClusterSize *int32 `json:"clusterSize,omitempty"` -} - -// MarshalJSON is the custom marshaler for ManagementCluster. -func (mc ManagementCluster) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if mc.ClusterSize != nil { - objectMap["clusterSize"] = mc.ClusterSize - } - return json.Marshal(objectMap) -} - -// Operation a REST API operation -type Operation struct { - // Name - READ-ONLY; Name of the operation being performed on this object - Name *string `json:"name,omitempty"` - // Display - READ-ONLY; Contains the localized display information for this operation - Display *OperationDisplay `json:"display,omitempty"` -} - -// OperationDisplay contains the localized display information for this operation -type OperationDisplay struct { - // Provider - READ-ONLY; Localized friendly form of the resource provider name - Provider *string `json:"provider,omitempty"` - // Resource - READ-ONLY; Localized friendly form of the resource type related to this operation - Resource *string `json:"resource,omitempty"` - // Operation - READ-ONLY; Localized friendly name for the operation - Operation *string `json:"operation,omitempty"` - // Description - READ-ONLY; Localized friendly description for the operation - Description *string `json:"description,omitempty"` -} - -// OperationList pageable list of operations -type OperationList struct { - autorest.Response `json:"-"` - // Value - READ-ONLY; List of operations - Value *[]Operation `json:"value,omitempty"` - // NextLink - READ-ONLY; URL to get the next page if any - NextLink *string `json:"nextLink,omitempty"` -} - -// OperationListIterator provides access to a complete listing of Operation values. -type OperationListIterator struct { - i int - page OperationListPage -} - -// 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 *OperationListIterator) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/OperationListIterator.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 *OperationListIterator) Next() error { - return iter.NextWithContext(context.Background()) -} - -// NotDone returns true if the enumeration should be started or is not yet complete. -func (iter OperationListIterator) 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 OperationListIterator) Response() OperationList { - 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 OperationListIterator) Value() Operation { - if !iter.page.NotDone() { - return Operation{} - } - return iter.page.Values()[iter.i] -} - -// Creates a new instance of the OperationListIterator type. -func NewOperationListIterator(page OperationListPage) OperationListIterator { - return OperationListIterator{page: page} -} - -// IsEmpty returns true if the ListResult contains no values. -func (ol OperationList) IsEmpty() bool { - return ol.Value == nil || len(*ol.Value) == 0 -} - -// hasNextLink returns true if the NextLink is not empty. -func (ol OperationList) hasNextLink() bool { - return ol.NextLink != nil && len(*ol.NextLink) != 0 -} - -// operationListPreparer prepares a request to retrieve the next set of results. -// It returns nil if no more results exist. -func (ol OperationList) operationListPreparer(ctx context.Context) (*http.Request, error) { - if !ol.hasNextLink() { - return nil, nil - } - return autorest.Prepare((&http.Request{}).WithContext(ctx), - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(ol.NextLink))) -} - -// OperationListPage contains a page of Operation values. -type OperationListPage struct { - fn func(context.Context, OperationList) (OperationList, error) - ol OperationList -} - -// 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 *OperationListPage) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/OperationListPage.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.ol) - if err != nil { - return err - } - page.ol = 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 *OperationListPage) Next() error { - return page.NextWithContext(context.Background()) -} - -// NotDone returns true if the page enumeration should be started or is not yet complete. -func (page OperationListPage) NotDone() bool { - return !page.ol.IsEmpty() -} - -// Response returns the raw server response from the last page request. -func (page OperationListPage) Response() OperationList { - return page.ol -} - -// Values returns the slice of values for the current page or nil if there are no values. -func (page OperationListPage) Values() []Operation { - if page.ol.IsEmpty() { - return nil - } - return *page.ol.Value -} - -// Creates a new instance of the OperationListPage type. -func NewOperationListPage(getNextPage func(context.Context, OperationList) (OperationList, error)) OperationListPage { - return OperationListPage{fn: getNextPage} -} - -// PrivateCloud a private cloud resource -type PrivateCloud struct { - autorest.Response `json:"-"` - // Sku - The private cloud SKU - Sku *Sku `json:"sku,omitempty"` - // PrivateCloudProperties - The properties of a private cloud resource - *PrivateCloudProperties `json:"properties,omitempty"` - // Location - Resource location - Location *string `json:"location,omitempty"` - // Tags - Resource tags - Tags map[string]*string `json:"tags"` - // 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"` -} - -// MarshalJSON is the custom marshaler for PrivateCloud. -func (pc PrivateCloud) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if pc.Sku != nil { - objectMap["sku"] = pc.Sku - } - if pc.PrivateCloudProperties != nil { - objectMap["properties"] = pc.PrivateCloudProperties - } - if pc.Location != nil { - objectMap["location"] = pc.Location - } - if pc.Tags != nil { - objectMap["tags"] = pc.Tags - } - return json.Marshal(objectMap) -} - -// UnmarshalJSON is the custom unmarshaler for PrivateCloud struct. -func (pc *PrivateCloud) 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 - } - pc.Sku = &sku - } - case "properties": - if v != nil { - var privateCloudProperties PrivateCloudProperties - err = json.Unmarshal(*v, &privateCloudProperties) - if err != nil { - return err - } - pc.PrivateCloudProperties = &privateCloudProperties - } - case "location": - if v != nil { - var location string - err = json.Unmarshal(*v, &location) - if err != nil { - return err - } - pc.Location = &location - } - case "tags": - if v != nil { - var tags map[string]*string - err = json.Unmarshal(*v, &tags) - if err != nil { - return err - } - pc.Tags = tags - } - case "id": - if v != nil { - var ID string - err = json.Unmarshal(*v, &ID) - if err != nil { - return err - } - pc.ID = &ID - } - case "name": - if v != nil { - var name string - err = json.Unmarshal(*v, &name) - if err != nil { - return err - } - pc.Name = &name - } - case "type": - if v != nil { - var typeVar string - err = json.Unmarshal(*v, &typeVar) - if err != nil { - return err - } - pc.Type = &typeVar - } - } - } - - return nil -} - -// PrivateCloudList a paged list of private clouds -type PrivateCloudList struct { - autorest.Response `json:"-"` - // Value - READ-ONLY; The items on the page - Value *[]PrivateCloud `json:"value,omitempty"` - // NextLink - READ-ONLY; URL to get the next page if any - NextLink *string `json:"nextLink,omitempty"` -} - -// PrivateCloudListIterator provides access to a complete listing of PrivateCloud values. -type PrivateCloudListIterator struct { - i int - page PrivateCloudListPage -} - -// 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 *PrivateCloudListIterator) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudListIterator.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 *PrivateCloudListIterator) Next() error { - return iter.NextWithContext(context.Background()) -} - -// NotDone returns true if the enumeration should be started or is not yet complete. -func (iter PrivateCloudListIterator) 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 PrivateCloudListIterator) Response() PrivateCloudList { - 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 PrivateCloudListIterator) Value() PrivateCloud { - if !iter.page.NotDone() { - return PrivateCloud{} - } - return iter.page.Values()[iter.i] -} - -// Creates a new instance of the PrivateCloudListIterator type. -func NewPrivateCloudListIterator(page PrivateCloudListPage) PrivateCloudListIterator { - return PrivateCloudListIterator{page: page} -} - -// IsEmpty returns true if the ListResult contains no values. -func (pcl PrivateCloudList) IsEmpty() bool { - return pcl.Value == nil || len(*pcl.Value) == 0 -} - -// hasNextLink returns true if the NextLink is not empty. -func (pcl PrivateCloudList) hasNextLink() bool { - return pcl.NextLink != nil && len(*pcl.NextLink) != 0 -} - -// privateCloudListPreparer prepares a request to retrieve the next set of results. -// It returns nil if no more results exist. -func (pcl PrivateCloudList) privateCloudListPreparer(ctx context.Context) (*http.Request, error) { - if !pcl.hasNextLink() { - return nil, nil - } - return autorest.Prepare((&http.Request{}).WithContext(ctx), - autorest.AsJSON(), - autorest.AsGet(), - autorest.WithBaseURL(to.String(pcl.NextLink))) -} - -// PrivateCloudListPage contains a page of PrivateCloud values. -type PrivateCloudListPage struct { - fn func(context.Context, PrivateCloudList) (PrivateCloudList, error) - pcl PrivateCloudList -} - -// 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 *PrivateCloudListPage) NextWithContext(ctx context.Context) (err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudListPage.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.pcl) - if err != nil { - return err - } - page.pcl = 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 *PrivateCloudListPage) Next() error { - return page.NextWithContext(context.Background()) -} - -// NotDone returns true if the page enumeration should be started or is not yet complete. -func (page PrivateCloudListPage) NotDone() bool { - return !page.pcl.IsEmpty() -} - -// Response returns the raw server response from the last page request. -func (page PrivateCloudListPage) Response() PrivateCloudList { - return page.pcl -} - -// Values returns the slice of values for the current page or nil if there are no values. -func (page PrivateCloudListPage) Values() []PrivateCloud { - if page.pcl.IsEmpty() { - return nil - } - return *page.pcl.Value -} - -// Creates a new instance of the PrivateCloudListPage type. -func NewPrivateCloudListPage(getNextPage func(context.Context, PrivateCloudList) (PrivateCloudList, error)) PrivateCloudListPage { - return PrivateCloudListPage{fn: getNextPage} -} - -// PrivateCloudProperties the properties of a private cloud resource -type PrivateCloudProperties struct { - // ProvisioningState - READ-ONLY; The provisioning state. Possible values include: 'PrivateCloudProvisioningStateSucceeded', 'PrivateCloudProvisioningStateFailed', 'PrivateCloudProvisioningStateCancelled', 'PrivateCloudProvisioningStatePending', 'PrivateCloudProvisioningStateBuilding', 'PrivateCloudProvisioningStateDeleting', 'PrivateCloudProvisioningStateUpdating' - ProvisioningState PrivateCloudProvisioningState `json:"provisioningState,omitempty"` - // Circuit - An ExpressRoute Circuit - Circuit *Circuit `json:"circuit,omitempty"` - // Endpoints - READ-ONLY; The endpoints - Endpoints *Endpoints `json:"endpoints,omitempty"` - // NetworkBlock - The block of addresses should be unique across VNet in your subscription as well as on-premise. Make sure the CIDR format is conformed to (A.B.C.D/X) where A,B,C,D are between 0 and 255, and X is between 0 and 22 - NetworkBlock *string `json:"networkBlock,omitempty"` - // ManagementNetwork - READ-ONLY; Network used to access vCenter Server and NSX-T Manager - ManagementNetwork *string `json:"managementNetwork,omitempty"` - // ProvisioningNetwork - READ-ONLY; Used for virtual machine cold migration, cloning, and snapshot migration - ProvisioningNetwork *string `json:"provisioningNetwork,omitempty"` - // VmotionNetwork - READ-ONLY; Used for live migration of virtual machines - VmotionNetwork *string `json:"vmotionNetwork,omitempty"` - // VcenterPassword - Optionally, set the vCenter admin password when the private cloud is created - VcenterPassword *string `json:"vcenterPassword,omitempty"` - // NsxtPassword - Optionally, set the NSX-T Manager password when the private cloud is created - NsxtPassword *string `json:"nsxtPassword,omitempty"` - // VcenterCertificateThumbprint - READ-ONLY; Thumbprint of the vCenter Server SSL certificate - VcenterCertificateThumbprint *string `json:"vcenterCertificateThumbprint,omitempty"` - // NsxtCertificateThumbprint - READ-ONLY; Thumbprint of the NSX-T Manager SSL certificate - NsxtCertificateThumbprint *string `json:"nsxtCertificateThumbprint,omitempty"` - // ManagementCluster - The default cluster used for management - ManagementCluster *ManagementCluster `json:"managementCluster,omitempty"` - // Internet - Connectivity to internet is enabled or disabled. Possible values include: 'Enabled', 'Disabled' - Internet InternetEnum `json:"internet,omitempty"` - // IdentitySources - vCenter Single Sign On Identity Sources - IdentitySources *[]IdentitySource `json:"identitySources,omitempty"` -} - -// MarshalJSON is the custom marshaler for PrivateCloudProperties. -func (pcp PrivateCloudProperties) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if pcp.Circuit != nil { - objectMap["circuit"] = pcp.Circuit - } - if pcp.NetworkBlock != nil { - objectMap["networkBlock"] = pcp.NetworkBlock - } - if pcp.VcenterPassword != nil { - objectMap["vcenterPassword"] = pcp.VcenterPassword - } - if pcp.NsxtPassword != nil { - objectMap["nsxtPassword"] = pcp.NsxtPassword - } - if pcp.ManagementCluster != nil { - objectMap["managementCluster"] = pcp.ManagementCluster - } - if pcp.Internet != "" { - objectMap["internet"] = pcp.Internet - } - if pcp.IdentitySources != nil { - objectMap["identitySources"] = pcp.IdentitySources - } - return json.Marshal(objectMap) -} - -// PrivateCloudsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. -type PrivateCloudsCreateOrUpdateFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *PrivateCloudsCreateOrUpdateFuture) Result(client PrivateCloudsClient) (pc PrivateCloud, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsCreateOrUpdateFuture") - return - } - sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) - if pc.Response.Response, err = future.GetResult(sender); err == nil && pc.Response.Response.StatusCode != http.StatusNoContent { - pc, err = client.CreateOrUpdateResponder(pc.Response.Response) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsCreateOrUpdateFuture", "Result", pc.Response.Response, "Failure responding to request") - } - } - return -} - -// PrivateCloudsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. -type PrivateCloudsDeleteFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *PrivateCloudsDeleteFuture) Result(client PrivateCloudsClient) (ar autorest.Response, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsDeleteFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsDeleteFuture") - return - } - ar.Response = future.Response() - return -} - -// PrivateCloudsUpdateFuture an abstraction for monitoring and retrieving the results of a long-running -// operation. -type PrivateCloudsUpdateFuture struct { - azure.Future -} - -// Result returns the result of the asynchronous operation. -// If the operation has not completed it will return an error. -func (future *PrivateCloudsUpdateFuture) Result(client PrivateCloudsClient) (pc PrivateCloud, err error) { - var done bool - done, err = future.DoneWithContext(context.Background(), client) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsUpdateFuture", "Result", future.Response(), "Polling failure") - return - } - if !done { - err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsUpdateFuture") - return - } - sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) - if pc.Response.Response, err = future.GetResult(sender); err == nil && pc.Response.Response.StatusCode != http.StatusNoContent { - pc, err = client.UpdateResponder(pc.Response.Response) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsUpdateFuture", "Result", pc.Response.Response, "Failure responding to request") - } - } - return -} - -// PrivateCloudUpdate an update to a private cloud resource -type PrivateCloudUpdate struct { - // Tags - Resource tags. - Tags map[string]*string `json:"tags"` - // PrivateCloudUpdateProperties - The updatable properties of a private cloud resource - *PrivateCloudUpdateProperties `json:"properties,omitempty"` -} - -// MarshalJSON is the custom marshaler for PrivateCloudUpdate. -func (pcu PrivateCloudUpdate) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if pcu.Tags != nil { - objectMap["tags"] = pcu.Tags - } - if pcu.PrivateCloudUpdateProperties != nil { - objectMap["properties"] = pcu.PrivateCloudUpdateProperties - } - return json.Marshal(objectMap) -} - -// UnmarshalJSON is the custom unmarshaler for PrivateCloudUpdate struct. -func (pcu *PrivateCloudUpdate) 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 "tags": - if v != nil { - var tags map[string]*string - err = json.Unmarshal(*v, &tags) - if err != nil { - return err - } - pcu.Tags = tags - } - case "properties": - if v != nil { - var privateCloudUpdateProperties PrivateCloudUpdateProperties - err = json.Unmarshal(*v, &privateCloudUpdateProperties) - if err != nil { - return err - } - pcu.PrivateCloudUpdateProperties = &privateCloudUpdateProperties - } - } - } - - return nil -} - -// PrivateCloudUpdateProperties the properties of a private cloud resource that may be updated -type PrivateCloudUpdateProperties struct { - // ManagementCluster - The default cluster used for management - ManagementCluster *ManagementCluster `json:"managementCluster,omitempty"` - // Internet - Connectivity to internet is enabled or disabled. Possible values include: 'Enabled', 'Disabled' - Internet InternetEnum `json:"internet,omitempty"` - // IdentitySources - vCenter Single Sign On Identity Sources - IdentitySources *[]IdentitySource `json:"identitySources,omitempty"` -} - -// Quota subscription quotas -type Quota struct { - autorest.Response `json:"-"` - // HostsRemaining - READ-ONLY; Remaining hosts quota by sku type - HostsRemaining map[string]*int32 `json:"hostsRemaining"` - // QuotaEnabled - READ-ONLY; Host quota is active for current subscription. Possible values include: 'QuotaEnabledEnabled', 'QuotaEnabledDisabled' - QuotaEnabled QuotaEnabled `json:"quotaEnabled,omitempty"` -} - -// MarshalJSON is the custom marshaler for Quota. -func (q Quota) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - return json.Marshal(objectMap) -} - -// Resource the core properties of ARM resources -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"` -} - -// Sku the resource model definition representing SKU -type Sku struct { - // Name - The name of the SKU. - Name *string `json:"name,omitempty"` -} - -// TrackedResource the resource model definition for a ARM tracked top level resource -type TrackedResource struct { - // Location - Resource location - Location *string `json:"location,omitempty"` - // Tags - Resource tags - Tags map[string]*string `json:"tags"` - // 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"` -} - -// MarshalJSON is the custom marshaler for TrackedResource. -func (tr TrackedResource) MarshalJSON() ([]byte, error) { - objectMap := make(map[string]interface{}) - if tr.Location != nil { - objectMap["location"] = tr.Location - } - if tr.Tags != nil { - objectMap["tags"] = tr.Tags - } - return json.Marshal(objectMap) -} - -// Trial subscription trial availability -type Trial struct { - autorest.Response `json:"-"` - // Status - READ-ONLY; Trial status. Possible values include: 'TrialAvailable', 'TrialUsed', 'TrialDisabled' - Status TrialStatus `json:"status,omitempty"` - // AvailableHosts - READ-ONLY; Number of trial hosts available - AvailableHosts *int32 `json:"availableHosts,omitempty"` -} +package avs + +// 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/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/avs/mgmt/2020-03-20/avs" + +// ClusterProvisioningState enumerates the values for cluster provisioning state. +type ClusterProvisioningState string + +const ( + // Cancelled ... + Cancelled ClusterProvisioningState = "Cancelled" + // Deleting ... + Deleting ClusterProvisioningState = "Deleting" + // Failed ... + Failed ClusterProvisioningState = "Failed" + // Succeeded ... + Succeeded ClusterProvisioningState = "Succeeded" + // Updating ... + Updating ClusterProvisioningState = "Updating" +) + +// PossibleClusterProvisioningStateValues returns an array of possible values for the ClusterProvisioningState const type. +func PossibleClusterProvisioningStateValues() []ClusterProvisioningState { + return []ClusterProvisioningState{Cancelled, Deleting, Failed, Succeeded, Updating} +} + +// ExpressRouteAuthorizationProvisioningState enumerates the values for express route authorization +// provisioning state. +type ExpressRouteAuthorizationProvisioningState string + +const ( + // ExpressRouteAuthorizationProvisioningStateFailed ... + ExpressRouteAuthorizationProvisioningStateFailed ExpressRouteAuthorizationProvisioningState = "Failed" + // ExpressRouteAuthorizationProvisioningStateSucceeded ... + ExpressRouteAuthorizationProvisioningStateSucceeded ExpressRouteAuthorizationProvisioningState = "Succeeded" + // ExpressRouteAuthorizationProvisioningStateUpdating ... + ExpressRouteAuthorizationProvisioningStateUpdating ExpressRouteAuthorizationProvisioningState = "Updating" +) + +// PossibleExpressRouteAuthorizationProvisioningStateValues returns an array of possible values for the ExpressRouteAuthorizationProvisioningState const type. +func PossibleExpressRouteAuthorizationProvisioningStateValues() []ExpressRouteAuthorizationProvisioningState { + return []ExpressRouteAuthorizationProvisioningState{ExpressRouteAuthorizationProvisioningStateFailed, ExpressRouteAuthorizationProvisioningStateSucceeded, ExpressRouteAuthorizationProvisioningStateUpdating} +} + +// HcxEnterpriseSiteStatus enumerates the values for hcx enterprise site status. +type HcxEnterpriseSiteStatus string + +const ( + // Available ... + Available HcxEnterpriseSiteStatus = "Available" + // Consumed ... + Consumed HcxEnterpriseSiteStatus = "Consumed" + // Deactivated ... + Deactivated HcxEnterpriseSiteStatus = "Deactivated" + // Deleted ... + Deleted HcxEnterpriseSiteStatus = "Deleted" +) + +// PossibleHcxEnterpriseSiteStatusValues returns an array of possible values for the HcxEnterpriseSiteStatus const type. +func PossibleHcxEnterpriseSiteStatusValues() []HcxEnterpriseSiteStatus { + return []HcxEnterpriseSiteStatus{Available, Consumed, Deactivated, Deleted} +} + +// InternetEnum enumerates the values for internet enum. +type InternetEnum string + +const ( + // Disabled ... + Disabled InternetEnum = "Disabled" + // Enabled ... + Enabled InternetEnum = "Enabled" +) + +// PossibleInternetEnumValues returns an array of possible values for the InternetEnum const type. +func PossibleInternetEnumValues() []InternetEnum { + return []InternetEnum{Disabled, Enabled} +} + +// PrivateCloudProvisioningState enumerates the values for private cloud provisioning state. +type PrivateCloudProvisioningState string + +const ( + // PrivateCloudProvisioningStateBuilding ... + PrivateCloudProvisioningStateBuilding PrivateCloudProvisioningState = "Building" + // PrivateCloudProvisioningStateCancelled ... + PrivateCloudProvisioningStateCancelled PrivateCloudProvisioningState = "Cancelled" + // PrivateCloudProvisioningStateDeleting ... + PrivateCloudProvisioningStateDeleting PrivateCloudProvisioningState = "Deleting" + // PrivateCloudProvisioningStateFailed ... + PrivateCloudProvisioningStateFailed PrivateCloudProvisioningState = "Failed" + // PrivateCloudProvisioningStatePending ... + PrivateCloudProvisioningStatePending PrivateCloudProvisioningState = "Pending" + // PrivateCloudProvisioningStateSucceeded ... + PrivateCloudProvisioningStateSucceeded PrivateCloudProvisioningState = "Succeeded" + // PrivateCloudProvisioningStateUpdating ... + PrivateCloudProvisioningStateUpdating PrivateCloudProvisioningState = "Updating" +) + +// PossiblePrivateCloudProvisioningStateValues returns an array of possible values for the PrivateCloudProvisioningState const type. +func PossiblePrivateCloudProvisioningStateValues() []PrivateCloudProvisioningState { + return []PrivateCloudProvisioningState{PrivateCloudProvisioningStateBuilding, PrivateCloudProvisioningStateCancelled, PrivateCloudProvisioningStateDeleting, PrivateCloudProvisioningStateFailed, PrivateCloudProvisioningStatePending, PrivateCloudProvisioningStateSucceeded, PrivateCloudProvisioningStateUpdating} +} + +// QuotaEnabled enumerates the values for quota enabled. +type QuotaEnabled string + +const ( + // QuotaEnabledDisabled ... + QuotaEnabledDisabled QuotaEnabled = "Disabled" + // QuotaEnabledEnabled ... + QuotaEnabledEnabled QuotaEnabled = "Enabled" +) + +// PossibleQuotaEnabledValues returns an array of possible values for the QuotaEnabled const type. +func PossibleQuotaEnabledValues() []QuotaEnabled { + return []QuotaEnabled{QuotaEnabledDisabled, QuotaEnabledEnabled} +} + +// SslEnum enumerates the values for ssl enum. +type SslEnum string + +const ( + // SslEnumDisabled ... + SslEnumDisabled SslEnum = "Disabled" + // SslEnumEnabled ... + SslEnumEnabled SslEnum = "Enabled" +) + +// PossibleSslEnumValues returns an array of possible values for the SslEnum const type. +func PossibleSslEnumValues() []SslEnum { + return []SslEnum{SslEnumDisabled, SslEnumEnabled} +} + +// TrialStatus enumerates the values for trial status. +type TrialStatus string + +const ( + // TrialAvailable ... + TrialAvailable TrialStatus = "TrialAvailable" + // TrialDisabled ... + TrialDisabled TrialStatus = "TrialDisabled" + // TrialUsed ... + TrialUsed TrialStatus = "TrialUsed" +) + +// PossibleTrialStatusValues returns an array of possible values for the TrialStatus const type. +func PossibleTrialStatusValues() []TrialStatus { + return []TrialStatus{TrialAvailable, TrialDisabled, TrialUsed} +} + +// AdminCredentials administrative credentials for accessing vCenter and NSX-T +type AdminCredentials struct { + autorest.Response `json:"-"` + // NsxtUsername - READ-ONLY; NSX-T Manager username + NsxtUsername *string `json:"nsxtUsername,omitempty"` + // NsxtPassword - READ-ONLY; NSX-T Manager password + NsxtPassword *string `json:"nsxtPassword,omitempty"` + // VcenterUsername - READ-ONLY; vCenter admin username + VcenterUsername *string `json:"vcenterUsername,omitempty"` + // VcenterPassword - READ-ONLY; vCenter admin password + VcenterPassword *string `json:"vcenterPassword,omitempty"` +} + +// AuthorizationsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. +type AuthorizationsCreateOrUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *AuthorizationsCreateOrUpdateFuture) Result(client AuthorizationsClient) (era ExpressRouteAuthorization, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.AuthorizationsCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if era.Response.Response, err = future.GetResult(sender); err == nil && era.Response.Response.StatusCode != http.StatusNoContent { + era, err = client.CreateOrUpdateResponder(era.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsCreateOrUpdateFuture", "Result", era.Response.Response, "Failure responding to request") + } + } + return +} + +// AuthorizationsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type AuthorizationsDeleteFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *AuthorizationsDeleteFuture) Result(client AuthorizationsClient) (ar autorest.Response, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.AuthorizationsDeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.AuthorizationsDeleteFuture") + return + } + ar.Response = future.Response() + return +} + +// Circuit an ExpressRoute Circuit +type Circuit struct { + // PrimarySubnet - READ-ONLY; CIDR of primary subnet + PrimarySubnet *string `json:"primarySubnet,omitempty"` + // SecondarySubnet - READ-ONLY; CIDR of secondary subnet + SecondarySubnet *string `json:"secondarySubnet,omitempty"` + // ExpressRouteID - READ-ONLY; Identifier of the ExpressRoute Circuit (Microsoft Colo only) + ExpressRouteID *string `json:"expressRouteID,omitempty"` + // ExpressRoutePrivatePeeringID - READ-ONLY; ExpressRoute Circuit private peering identifier + ExpressRoutePrivatePeeringID *string `json:"expressRoutePrivatePeeringID,omitempty"` +} + +// CloudError API error response +type CloudError struct { + // Error - An error returned by the API + Error *ErrorResponse `json:"error,omitempty"` +} + +// Cluster a cluster resource +type Cluster struct { + autorest.Response `json:"-"` + // Sku - The cluster SKU + Sku *Sku `json:"sku,omitempty"` + // ClusterProperties - The properties of a cluster resource + *ClusterProperties `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"` +} + +// MarshalJSON is the custom marshaler for Cluster. +func (c Cluster) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if c.Sku != nil { + objectMap["sku"] = c.Sku + } + if c.ClusterProperties != nil { + objectMap["properties"] = c.ClusterProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for Cluster struct. +func (c *Cluster) 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 + } + c.Sku = &sku + } + case "properties": + if v != nil { + var clusterProperties ClusterProperties + err = json.Unmarshal(*v, &clusterProperties) + if err != nil { + return err + } + c.ClusterProperties = &clusterProperties + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + c.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + c.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + c.Type = &typeVar + } + } + } + + return nil +} + +// ClusterList a paged list of clusters +type ClusterList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on a page + Value *[]Cluster `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// ClusterListIterator provides access to a complete listing of Cluster values. +type ClusterListIterator struct { + i int + page ClusterListPage +} + +// 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 *ClusterListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClusterListIterator.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 *ClusterListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter ClusterListIterator) 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 ClusterListIterator) Response() ClusterList { + 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 ClusterListIterator) Value() Cluster { + if !iter.page.NotDone() { + return Cluster{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the ClusterListIterator type. +func NewClusterListIterator(page ClusterListPage) ClusterListIterator { + return ClusterListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (cl ClusterList) IsEmpty() bool { + return cl.Value == nil || len(*cl.Value) == 0 +} + +// clusterListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (cl ClusterList) clusterListPreparer(ctx context.Context) (*http.Request, error) { + if cl.NextLink == nil || len(to.String(cl.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(cl.NextLink))) +} + +// ClusterListPage contains a page of Cluster values. +type ClusterListPage struct { + fn func(context.Context, ClusterList) (ClusterList, error) + cl ClusterList +} + +// 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 *ClusterListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ClusterListPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.cl) + if err != nil { + return err + } + page.cl = next + 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 *ClusterListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page ClusterListPage) NotDone() bool { + return !page.cl.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page ClusterListPage) Response() ClusterList { + return page.cl +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page ClusterListPage) Values() []Cluster { + if page.cl.IsEmpty() { + return nil + } + return *page.cl.Value +} + +// Creates a new instance of the ClusterListPage type. +func NewClusterListPage(getNextPage func(context.Context, ClusterList) (ClusterList, error)) ClusterListPage { + return ClusterListPage{fn: getNextPage} +} + +// ClusterProperties the properties of a cluster +type ClusterProperties struct { + // ProvisioningState - READ-ONLY; The state of the cluster provisioning. Possible values include: 'Succeeded', 'Failed', 'Cancelled', 'Deleting', 'Updating' + ProvisioningState ClusterProvisioningState `json:"provisioningState,omitempty"` + // ClusterID - READ-ONLY; The identity + ClusterID *int32 `json:"clusterId,omitempty"` + // Hosts - READ-ONLY; The hosts + Hosts *[]string `json:"hosts,omitempty"` + // ClusterSize - The cluster size + ClusterSize *int32 `json:"clusterSize,omitempty"` +} + +// ClustersCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type ClustersCreateOrUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *ClustersCreateOrUpdateFuture) Result(client ClustersClient) (c Cluster, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.ClustersCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { + c, err = client.CreateOrUpdateResponder(c.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersCreateOrUpdateFuture", "Result", c.Response.Response, "Failure responding to request") + } + } + return +} + +// ClustersDeleteFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type ClustersDeleteFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *ClustersDeleteFuture) Result(client ClustersClient) (ar autorest.Response, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersDeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.ClustersDeleteFuture") + return + } + ar.Response = future.Response() + return +} + +// ClustersUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type ClustersUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *ClustersUpdateFuture) Result(client ClustersClient) (c Cluster, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.ClustersUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { + c, err = client.UpdateResponder(c.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.ClustersUpdateFuture", "Result", c.Response.Response, "Failure responding to request") + } + } + return +} + +// ClusterUpdate an update of a cluster resource +type ClusterUpdate struct { + // ClusterUpdateProperties - The properties of a cluster resource that may be updated + *ClusterUpdateProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for ClusterUpdate. +func (cu ClusterUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if cu.ClusterUpdateProperties != nil { + objectMap["properties"] = cu.ClusterUpdateProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for ClusterUpdate struct. +func (cu *ClusterUpdate) 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 clusterUpdateProperties ClusterUpdateProperties + err = json.Unmarshal(*v, &clusterUpdateProperties) + if err != nil { + return err + } + cu.ClusterUpdateProperties = &clusterUpdateProperties + } + } + } + + return nil +} + +// ClusterUpdateProperties the properties of a cluster that may be updated +type ClusterUpdateProperties struct { + // ClusterSize - The cluster size + ClusterSize *int32 `json:"clusterSize,omitempty"` +} + +// Endpoints endpoint addresses +type Endpoints struct { + // NsxtManager - READ-ONLY; Endpoint for the NSX-T Data Center manager + NsxtManager *string `json:"nsxtManager,omitempty"` + // Vcsa - READ-ONLY; Endpoint for Virtual Center Server Appliance + Vcsa *string `json:"vcsa,omitempty"` + // HcxCloudManager - READ-ONLY; Endpoint for the HCX Cloud Manager + HcxCloudManager *string `json:"hcxCloudManager,omitempty"` +} + +// ErrorAdditionalInfo the resource management error additional info. +type ErrorAdditionalInfo struct { + // Type - READ-ONLY; The additional info type. + Type *string `json:"type,omitempty"` + // Info - READ-ONLY; The additional info. + Info interface{} `json:"info,omitempty"` +} + +// ErrorResponse the resource management error response. +type ErrorResponse struct { + // Code - READ-ONLY; The error code. + Code *string `json:"code,omitempty"` + // Message - READ-ONLY; The error message. + Message *string `json:"message,omitempty"` + // Target - READ-ONLY; The error target. + Target *string `json:"target,omitempty"` + // Details - READ-ONLY; The error details. + Details *[]ErrorResponse `json:"details,omitempty"` + // AdditionalInfo - READ-ONLY; The error additional info. + AdditionalInfo *[]ErrorAdditionalInfo `json:"additionalInfo,omitempty"` +} + +// ExpressRouteAuthorization expressRoute Circuit Authorization +type ExpressRouteAuthorization struct { + autorest.Response `json:"-"` + // ExpressRouteAuthorizationProperties - The properties of an ExpressRoute Circuit Authorization resource + *ExpressRouteAuthorizationProperties `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"` +} + +// MarshalJSON is the custom marshaler for ExpressRouteAuthorization. +func (era ExpressRouteAuthorization) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if era.ExpressRouteAuthorizationProperties != nil { + objectMap["properties"] = era.ExpressRouteAuthorizationProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for ExpressRouteAuthorization struct. +func (era *ExpressRouteAuthorization) 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 expressRouteAuthorizationProperties ExpressRouteAuthorizationProperties + err = json.Unmarshal(*v, &expressRouteAuthorizationProperties) + if err != nil { + return err + } + era.ExpressRouteAuthorizationProperties = &expressRouteAuthorizationProperties + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + era.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + era.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + era.Type = &typeVar + } + } + } + + return nil +} + +// ExpressRouteAuthorizationList a paged list of ExpressRoute Circuit Authorizations +type ExpressRouteAuthorizationList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on a page + Value *[]ExpressRouteAuthorization `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// ExpressRouteAuthorizationListIterator provides access to a complete listing of ExpressRouteAuthorization +// values. +type ExpressRouteAuthorizationListIterator struct { + i int + page ExpressRouteAuthorizationListPage +} + +// 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 *ExpressRouteAuthorizationListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteAuthorizationListIterator.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 *ExpressRouteAuthorizationListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter ExpressRouteAuthorizationListIterator) 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 ExpressRouteAuthorizationListIterator) Response() ExpressRouteAuthorizationList { + 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 ExpressRouteAuthorizationListIterator) Value() ExpressRouteAuthorization { + if !iter.page.NotDone() { + return ExpressRouteAuthorization{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the ExpressRouteAuthorizationListIterator type. +func NewExpressRouteAuthorizationListIterator(page ExpressRouteAuthorizationListPage) ExpressRouteAuthorizationListIterator { + return ExpressRouteAuthorizationListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (eral ExpressRouteAuthorizationList) IsEmpty() bool { + return eral.Value == nil || len(*eral.Value) == 0 +} + +// expressRouteAuthorizationListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (eral ExpressRouteAuthorizationList) expressRouteAuthorizationListPreparer(ctx context.Context) (*http.Request, error) { + if eral.NextLink == nil || len(to.String(eral.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(eral.NextLink))) +} + +// ExpressRouteAuthorizationListPage contains a page of ExpressRouteAuthorization values. +type ExpressRouteAuthorizationListPage struct { + fn func(context.Context, ExpressRouteAuthorizationList) (ExpressRouteAuthorizationList, error) + eral ExpressRouteAuthorizationList +} + +// 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 *ExpressRouteAuthorizationListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteAuthorizationListPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.eral) + if err != nil { + return err + } + page.eral = next + 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 *ExpressRouteAuthorizationListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page ExpressRouteAuthorizationListPage) NotDone() bool { + return !page.eral.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page ExpressRouteAuthorizationListPage) Response() ExpressRouteAuthorizationList { + return page.eral +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page ExpressRouteAuthorizationListPage) Values() []ExpressRouteAuthorization { + if page.eral.IsEmpty() { + return nil + } + return *page.eral.Value +} + +// Creates a new instance of the ExpressRouteAuthorizationListPage type. +func NewExpressRouteAuthorizationListPage(getNextPage func(context.Context, ExpressRouteAuthorizationList) (ExpressRouteAuthorizationList, error)) ExpressRouteAuthorizationListPage { + return ExpressRouteAuthorizationListPage{fn: getNextPage} +} + +// ExpressRouteAuthorizationProperties the properties of an ExpressRoute Circuit Authorization resource +type ExpressRouteAuthorizationProperties struct { + // ProvisioningState - READ-ONLY; The state of the ExpressRoute Circuit Authorization provisioning. Possible values include: 'ExpressRouteAuthorizationProvisioningStateSucceeded', 'ExpressRouteAuthorizationProvisioningStateFailed', 'ExpressRouteAuthorizationProvisioningStateUpdating' + ProvisioningState ExpressRouteAuthorizationProvisioningState `json:"provisioningState,omitempty"` + // ExpressRouteAuthorizationID - READ-ONLY; The ID of the ExpressRoute Circuit Authorization + ExpressRouteAuthorizationID *string `json:"expressRouteAuthorizationId,omitempty"` + // ExpressRouteAuthorizationKey - READ-ONLY; The key of the ExpressRoute Circuit Authorization + ExpressRouteAuthorizationKey *string `json:"expressRouteAuthorizationKey,omitempty"` +} + +// HcxEnterpriseSite an HCX Enterprise Site resource +type HcxEnterpriseSite struct { + autorest.Response `json:"-"` + // HcxEnterpriseSiteProperties - The properties of an HCX Enterprise Site resource + *HcxEnterpriseSiteProperties `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"` +} + +// MarshalJSON is the custom marshaler for HcxEnterpriseSite. +func (hes HcxEnterpriseSite) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if hes.HcxEnterpriseSiteProperties != nil { + objectMap["properties"] = hes.HcxEnterpriseSiteProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for HcxEnterpriseSite struct. +func (hes *HcxEnterpriseSite) 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 hcxEnterpriseSiteProperties HcxEnterpriseSiteProperties + err = json.Unmarshal(*v, &hcxEnterpriseSiteProperties) + if err != nil { + return err + } + hes.HcxEnterpriseSiteProperties = &hcxEnterpriseSiteProperties + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + hes.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + hes.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + hes.Type = &typeVar + } + } + } + + return nil +} + +// HcxEnterpriseSiteList a paged list of HCX Enterprise Sites +type HcxEnterpriseSiteList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on a page + Value *[]HcxEnterpriseSite `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// HcxEnterpriseSiteListIterator provides access to a complete listing of HcxEnterpriseSite values. +type HcxEnterpriseSiteListIterator struct { + i int + page HcxEnterpriseSiteListPage +} + +// 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 *HcxEnterpriseSiteListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSiteListIterator.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 *HcxEnterpriseSiteListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter HcxEnterpriseSiteListIterator) 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 HcxEnterpriseSiteListIterator) Response() HcxEnterpriseSiteList { + 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 HcxEnterpriseSiteListIterator) Value() HcxEnterpriseSite { + if !iter.page.NotDone() { + return HcxEnterpriseSite{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the HcxEnterpriseSiteListIterator type. +func NewHcxEnterpriseSiteListIterator(page HcxEnterpriseSiteListPage) HcxEnterpriseSiteListIterator { + return HcxEnterpriseSiteListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (hesl HcxEnterpriseSiteList) IsEmpty() bool { + return hesl.Value == nil || len(*hesl.Value) == 0 +} + +// hcxEnterpriseSiteListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (hesl HcxEnterpriseSiteList) hcxEnterpriseSiteListPreparer(ctx context.Context) (*http.Request, error) { + if hesl.NextLink == nil || len(to.String(hesl.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(hesl.NextLink))) +} + +// HcxEnterpriseSiteListPage contains a page of HcxEnterpriseSite values. +type HcxEnterpriseSiteListPage struct { + fn func(context.Context, HcxEnterpriseSiteList) (HcxEnterpriseSiteList, error) + hesl HcxEnterpriseSiteList +} + +// 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 *HcxEnterpriseSiteListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HcxEnterpriseSiteListPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.hesl) + if err != nil { + return err + } + page.hesl = next + 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 *HcxEnterpriseSiteListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page HcxEnterpriseSiteListPage) NotDone() bool { + return !page.hesl.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page HcxEnterpriseSiteListPage) Response() HcxEnterpriseSiteList { + return page.hesl +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page HcxEnterpriseSiteListPage) Values() []HcxEnterpriseSite { + if page.hesl.IsEmpty() { + return nil + } + return *page.hesl.Value +} + +// Creates a new instance of the HcxEnterpriseSiteListPage type. +func NewHcxEnterpriseSiteListPage(getNextPage func(context.Context, HcxEnterpriseSiteList) (HcxEnterpriseSiteList, error)) HcxEnterpriseSiteListPage { + return HcxEnterpriseSiteListPage{fn: getNextPage} +} + +// HcxEnterpriseSiteProperties the properties of an HCX Enterprise Site +type HcxEnterpriseSiteProperties struct { + // ActivationKey - READ-ONLY; The activation key + ActivationKey *string `json:"activationKey,omitempty"` + // Status - READ-ONLY; The status of the HCX Enterprise Site. Possible values include: 'Available', 'Consumed', 'Deactivated', 'Deleted' + Status HcxEnterpriseSiteStatus `json:"status,omitempty"` +} + +// IdentitySource vCenter Single Sign On Identity Source +type IdentitySource struct { + // Name - The name of the identity source + Name *string `json:"name,omitempty"` + // Alias - The domain's NetBIOS name + Alias *string `json:"alias,omitempty"` + // Domain - The domain's dns name + Domain *string `json:"domain,omitempty"` + // BaseUserDN - The base distinguished name for users + BaseUserDN *string `json:"baseUserDN,omitempty"` + // BaseGroupDN - The base distinguished name for groups + BaseGroupDN *string `json:"baseGroupDN,omitempty"` + // PrimaryServer - Primary server URL + PrimaryServer *string `json:"primaryServer,omitempty"` + // SecondaryServer - Secondary server URL + SecondaryServer *string `json:"secondaryServer,omitempty"` + // Ssl - Protect LDAP communication using SSL certificate (LDAPS). Possible values include: 'SslEnumEnabled', 'SslEnumDisabled' + Ssl SslEnum `json:"ssl,omitempty"` + // Username - The ID of an Active Directory user with a minimum of read-only access to Base DN for users and group + Username *string `json:"username,omitempty"` + // Password - The password of the Active Directory user with a minimum of read-only access to Base DN for users and groups. + Password *string `json:"password,omitempty"` +} + +// ManagementCluster the properties of a default cluster +type ManagementCluster struct { + // ClusterID - READ-ONLY; The identity + ClusterID *int32 `json:"clusterId,omitempty"` + // Hosts - READ-ONLY; The hosts + Hosts *[]string `json:"hosts,omitempty"` + // ClusterSize - The cluster size + ClusterSize *int32 `json:"clusterSize,omitempty"` +} + +// Operation a REST API operation +type Operation struct { + // Name - READ-ONLY; Name of the operation being performed on this object + Name *string `json:"name,omitempty"` + // Display - READ-ONLY; Contains the localized display information for this operation + Display *OperationDisplay `json:"display,omitempty"` +} + +// OperationDisplay contains the localized display information for this operation +type OperationDisplay struct { + // Provider - READ-ONLY; Localized friendly form of the resource provider name + Provider *string `json:"provider,omitempty"` + // Resource - READ-ONLY; Localized friendly form of the resource type related to this operation + Resource *string `json:"resource,omitempty"` + // Operation - READ-ONLY; Localized friendly name for the operation + Operation *string `json:"operation,omitempty"` + // Description - READ-ONLY; Localized friendly description for the operation + Description *string `json:"description,omitempty"` +} + +// OperationList pageable list of operations +type OperationList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; List of operations + Value *[]Operation `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// OperationListIterator provides access to a complete listing of Operation values. +type OperationListIterator struct { + i int + page OperationListPage +} + +// 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 *OperationListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationListIterator.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 *OperationListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter OperationListIterator) 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 OperationListIterator) Response() OperationList { + 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 OperationListIterator) Value() Operation { + if !iter.page.NotDone() { + return Operation{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the OperationListIterator type. +func NewOperationListIterator(page OperationListPage) OperationListIterator { + return OperationListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (ol OperationList) IsEmpty() bool { + return ol.Value == nil || len(*ol.Value) == 0 +} + +// operationListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (ol OperationList) operationListPreparer(ctx context.Context) (*http.Request, error) { + if ol.NextLink == nil || len(to.String(ol.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(ol.NextLink))) +} + +// OperationListPage contains a page of Operation values. +type OperationListPage struct { + fn func(context.Context, OperationList) (OperationList, error) + ol OperationList +} + +// 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 *OperationListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationListPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.ol) + if err != nil { + return err + } + page.ol = next + 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 *OperationListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page OperationListPage) NotDone() bool { + return !page.ol.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page OperationListPage) Response() OperationList { + return page.ol +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page OperationListPage) Values() []Operation { + if page.ol.IsEmpty() { + return nil + } + return *page.ol.Value +} + +// Creates a new instance of the OperationListPage type. +func NewOperationListPage(getNextPage func(context.Context, OperationList) (OperationList, error)) OperationListPage { + return OperationListPage{fn: getNextPage} +} + +// PrivateCloud a private cloud resource +type PrivateCloud struct { + autorest.Response `json:"-"` + // Sku - The private cloud SKU + Sku *Sku `json:"sku,omitempty"` + // PrivateCloudProperties - The properties of a private cloud resource + *PrivateCloudProperties `json:"properties,omitempty"` + // Location - Resource location + Location *string `json:"location,omitempty"` + // Tags - Resource tags + Tags map[string]*string `json:"tags"` + // 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"` +} + +// MarshalJSON is the custom marshaler for PrivateCloud. +func (pc PrivateCloud) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if pc.Sku != nil { + objectMap["sku"] = pc.Sku + } + if pc.PrivateCloudProperties != nil { + objectMap["properties"] = pc.PrivateCloudProperties + } + if pc.Location != nil { + objectMap["location"] = pc.Location + } + if pc.Tags != nil { + objectMap["tags"] = pc.Tags + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for PrivateCloud struct. +func (pc *PrivateCloud) 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 + } + pc.Sku = &sku + } + case "properties": + if v != nil { + var privateCloudProperties PrivateCloudProperties + err = json.Unmarshal(*v, &privateCloudProperties) + if err != nil { + return err + } + pc.PrivateCloudProperties = &privateCloudProperties + } + case "location": + if v != nil { + var location string + err = json.Unmarshal(*v, &location) + if err != nil { + return err + } + pc.Location = &location + } + case "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + pc.Tags = tags + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + pc.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + pc.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + pc.Type = &typeVar + } + } + } + + return nil +} + +// PrivateCloudList a paged list of private clouds +type PrivateCloudList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; The items on the page + Value *[]PrivateCloud `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next page if any + NextLink *string `json:"nextLink,omitempty"` +} + +// PrivateCloudListIterator provides access to a complete listing of PrivateCloud values. +type PrivateCloudListIterator struct { + i int + page PrivateCloudListPage +} + +// 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 *PrivateCloudListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudListIterator.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 *PrivateCloudListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter PrivateCloudListIterator) 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 PrivateCloudListIterator) Response() PrivateCloudList { + 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 PrivateCloudListIterator) Value() PrivateCloud { + if !iter.page.NotDone() { + return PrivateCloud{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the PrivateCloudListIterator type. +func NewPrivateCloudListIterator(page PrivateCloudListPage) PrivateCloudListIterator { + return PrivateCloudListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (pcl PrivateCloudList) IsEmpty() bool { + return pcl.Value == nil || len(*pcl.Value) == 0 +} + +// privateCloudListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (pcl PrivateCloudList) privateCloudListPreparer(ctx context.Context) (*http.Request, error) { + if pcl.NextLink == nil || len(to.String(pcl.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(pcl.NextLink))) +} + +// PrivateCloudListPage contains a page of PrivateCloud values. +type PrivateCloudListPage struct { + fn func(context.Context, PrivateCloudList) (PrivateCloudList, error) + pcl PrivateCloudList +} + +// 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 *PrivateCloudListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudListPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.pcl) + if err != nil { + return err + } + page.pcl = next + 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 *PrivateCloudListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page PrivateCloudListPage) NotDone() bool { + return !page.pcl.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page PrivateCloudListPage) Response() PrivateCloudList { + return page.pcl +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page PrivateCloudListPage) Values() []PrivateCloud { + if page.pcl.IsEmpty() { + return nil + } + return *page.pcl.Value +} + +// Creates a new instance of the PrivateCloudListPage type. +func NewPrivateCloudListPage(getNextPage func(context.Context, PrivateCloudList) (PrivateCloudList, error)) PrivateCloudListPage { + return PrivateCloudListPage{fn: getNextPage} +} + +// PrivateCloudProperties the properties of a private cloud resource +type PrivateCloudProperties struct { + // ProvisioningState - READ-ONLY; The provisioning state. Possible values include: 'PrivateCloudProvisioningStateSucceeded', 'PrivateCloudProvisioningStateFailed', 'PrivateCloudProvisioningStateCancelled', 'PrivateCloudProvisioningStatePending', 'PrivateCloudProvisioningStateBuilding', 'PrivateCloudProvisioningStateDeleting', 'PrivateCloudProvisioningStateUpdating' + ProvisioningState PrivateCloudProvisioningState `json:"provisioningState,omitempty"` + // Circuit - An ExpressRoute Circuit + Circuit *Circuit `json:"circuit,omitempty"` + // Endpoints - READ-ONLY; The endpoints + Endpoints *Endpoints `json:"endpoints,omitempty"` + // NetworkBlock - The block of addresses should be unique across VNet in your subscription as well as on-premise. Make sure the CIDR format is conformed to (A.B.C.D/X) where A,B,C,D are between 0 and 255, and X is between 0 and 22 + NetworkBlock *string `json:"networkBlock,omitempty"` + // ManagementNetwork - READ-ONLY; Network used to access vCenter Server and NSX-T Manager + ManagementNetwork *string `json:"managementNetwork,omitempty"` + // ProvisioningNetwork - READ-ONLY; Used for virtual machine cold migration, cloning, and snapshot migration + ProvisioningNetwork *string `json:"provisioningNetwork,omitempty"` + // VmotionNetwork - READ-ONLY; Used for live migration of virtual machines + VmotionNetwork *string `json:"vmotionNetwork,omitempty"` + // VcenterPassword - Optionally, set the vCenter admin password when the private cloud is created + VcenterPassword *string `json:"vcenterPassword,omitempty"` + // NsxtPassword - Optionally, set the NSX-T Manager password when the private cloud is created + NsxtPassword *string `json:"nsxtPassword,omitempty"` + // VcenterCertificateThumbprint - READ-ONLY; Thumbprint of the vCenter Server SSL certificate + VcenterCertificateThumbprint *string `json:"vcenterCertificateThumbprint,omitempty"` + // NsxtCertificateThumbprint - READ-ONLY; Thumbprint of the NSX-T Manager SSL certificate + NsxtCertificateThumbprint *string `json:"nsxtCertificateThumbprint,omitempty"` + // ManagementCluster - The default cluster used for management + ManagementCluster *ManagementCluster `json:"managementCluster,omitempty"` + // Internet - Connectivity to internet is enabled or disabled. Possible values include: 'Enabled', 'Disabled' + Internet InternetEnum `json:"internet,omitempty"` + // IdentitySources - vCenter Single Sign On Identity Sources + IdentitySources *[]IdentitySource `json:"identitySources,omitempty"` +} + +// PrivateCloudsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. +type PrivateCloudsCreateOrUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *PrivateCloudsCreateOrUpdateFuture) Result(client PrivateCloudsClient) (pc PrivateCloud, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if pc.Response.Response, err = future.GetResult(sender); err == nil && pc.Response.Response.StatusCode != http.StatusNoContent { + pc, err = client.CreateOrUpdateResponder(pc.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsCreateOrUpdateFuture", "Result", pc.Response.Response, "Failure responding to request") + } + } + return +} + +// PrivateCloudsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type PrivateCloudsDeleteFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *PrivateCloudsDeleteFuture) Result(client PrivateCloudsClient) (ar autorest.Response, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsDeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsDeleteFuture") + return + } + ar.Response = future.Response() + return +} + +// PrivateCloudsUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type PrivateCloudsUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *PrivateCloudsUpdateFuture) Result(client PrivateCloudsClient) (pc PrivateCloud, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("avs.PrivateCloudsUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if pc.Response.Response, err = future.GetResult(sender); err == nil && pc.Response.Response.StatusCode != http.StatusNoContent { + pc, err = client.UpdateResponder(pc.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsUpdateFuture", "Result", pc.Response.Response, "Failure responding to request") + } + } + return +} + +// PrivateCloudUpdate an update to a private cloud resource +type PrivateCloudUpdate struct { + // Tags - Resource tags. + Tags map[string]*string `json:"tags"` + // PrivateCloudUpdateProperties - The updatable properties of a private cloud resource + *PrivateCloudUpdateProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for PrivateCloudUpdate. +func (pcu PrivateCloudUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if pcu.Tags != nil { + objectMap["tags"] = pcu.Tags + } + if pcu.PrivateCloudUpdateProperties != nil { + objectMap["properties"] = pcu.PrivateCloudUpdateProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for PrivateCloudUpdate struct. +func (pcu *PrivateCloudUpdate) 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 "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + pcu.Tags = tags + } + case "properties": + if v != nil { + var privateCloudUpdateProperties PrivateCloudUpdateProperties + err = json.Unmarshal(*v, &privateCloudUpdateProperties) + if err != nil { + return err + } + pcu.PrivateCloudUpdateProperties = &privateCloudUpdateProperties + } + } + } + + return nil +} + +// PrivateCloudUpdateProperties the properties of a private cloud resource that may be updated +type PrivateCloudUpdateProperties struct { + // ManagementCluster - The default cluster used for management + ManagementCluster *ManagementCluster `json:"managementCluster,omitempty"` + // Internet - Connectivity to internet is enabled or disabled. Possible values include: 'Enabled', 'Disabled' + Internet InternetEnum `json:"internet,omitempty"` + // IdentitySources - vCenter Single Sign On Identity Sources + IdentitySources *[]IdentitySource `json:"identitySources,omitempty"` +} + +// Quota subscription quotas +type Quota struct { + autorest.Response `json:"-"` + // HostsRemaining - READ-ONLY; Remaining hosts quota by sku type + HostsRemaining map[string]*int32 `json:"hostsRemaining"` + // QuotaEnabled - READ-ONLY; Host quota is active for current subscription. Possible values include: 'QuotaEnabledEnabled', 'QuotaEnabledDisabled' + QuotaEnabled QuotaEnabled `json:"quotaEnabled,omitempty"` +} + +// MarshalJSON is the custom marshaler for Quota. +func (q Quota) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// Resource the core properties of ARM resources +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"` +} + +// Sku the resource model definition representing SKU +type Sku struct { + // Name - The name of the SKU. + Name *string `json:"name,omitempty"` +} + +// TrackedResource the resource model definition for a ARM tracked top level resource +type TrackedResource struct { + // Location - Resource location + Location *string `json:"location,omitempty"` + // Tags - Resource tags + Tags map[string]*string `json:"tags"` + // 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"` +} + +// MarshalJSON is the custom marshaler for TrackedResource. +func (tr TrackedResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if tr.Location != nil { + objectMap["location"] = tr.Location + } + if tr.Tags != nil { + objectMap["tags"] = tr.Tags + } + return json.Marshal(objectMap) +} + +// Trial subscription trial availability +type Trial struct { + autorest.Response `json:"-"` + // Status - READ-ONLY; Trial status. Possible values include: 'TrialAvailable', 'TrialUsed', 'TrialDisabled' + Status TrialStatus `json:"status,omitempty"` + // AvailableHosts - READ-ONLY; Number of trial hosts available + AvailableHosts *int32 `json:"availableHosts,omitempty"` +} diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go index 765297556ad5..19476d3f8955 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/operations.go @@ -1,149 +1,146 @@ -package avs - -// 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 azure VMware Solution 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 operations -func (client OperationsClient) List(ctx context.Context) (result OperationListPage, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List") - defer func() { - sc := -1 - if result.ol.Response.Response != nil { - sc = result.ol.Response.Response.StatusCode - } - tracing.EndSpan(ctx, sc, err) - }() - } - result.fn = client.listNextResults - req, err := client.ListPreparer(ctx) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", nil, "Failure preparing request") - return - } - - resp, err := client.ListSender(req) - if err != nil { - result.ol.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", resp, "Failure sending request") - return - } - - result.ol, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", resp, "Failure responding to request") - } - if result.ol.hasNextLink() && result.ol.IsEmpty() { - err = result.NextWithContext(ctx) - } - - return -} - -// ListPreparer prepares the List request. -func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) { - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPath("/providers/Microsoft.AVS/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 OperationList, 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 OperationList) (result OperationList, err error) { - req, err := lastResults.operationListPreparer(ctx) - if err != nil { - return result, autorest.NewErrorWithError(err, "avs.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, "avs.OperationsClient", "listNextResults", resp, "Failure sending next results request") - } - result, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.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 OperationListIterator, 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 -} +package avs + +// 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 azure VMware Solution 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 operations +func (client OperationsClient) List(ctx context.Context) (result OperationListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List") + defer func() { + sc := -1 + if result.ol.Response.Response != nil { + sc = result.ol.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.ol.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", resp, "Failure sending request") + return + } + + result.ol, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.OperationsClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) { + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.AVS/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 OperationList, 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 OperationList) (result OperationList, err error) { + req, err := lastResults.operationListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.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, "avs.OperationsClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.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 OperationListIterator, 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/avs/mgmt/2020-03-20/avs/privateclouds.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/privateclouds.go index 82af8e23b5ba..c31ab8f53081 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/privateclouds.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/privateclouds.go @@ -1,719 +1,713 @@ -package avs - -// 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" -) - -// PrivateCloudsClient is the azure VMware Solution API -type PrivateCloudsClient struct { - BaseClient -} - -// NewPrivateCloudsClient creates an instance of the PrivateCloudsClient client. -func NewPrivateCloudsClient(subscriptionID string) PrivateCloudsClient { - return NewPrivateCloudsClientWithBaseURI(DefaultBaseURI, subscriptionID) -} - -// NewPrivateCloudsClientWithBaseURI creates an instance of the PrivateCloudsClient 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 NewPrivateCloudsClientWithBaseURI(baseURI string, subscriptionID string) PrivateCloudsClient { - return PrivateCloudsClient{NewWithBaseURI(baseURI, subscriptionID)} -} - -// CreateOrUpdate sends the create or update request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// privateCloud - the private cloud -func (client PrivateCloudsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud PrivateCloud) (result PrivateCloudsCreateOrUpdateFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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: privateCloud, - Constraints: []validation.Constraint{{Target: "privateCloud.Sku", Name: validation.Null, Rule: true, - Chain: []validation.Constraint{{Target: "privateCloud.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}, - {Target: "privateCloud.PrivateCloudProperties", Name: validation.Null, Rule: true, - Chain: []validation.Constraint{{Target: "privateCloud.PrivateCloudProperties.NetworkBlock", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { - return result, validation.NewError("avs.PrivateCloudsClient", "CreateOrUpdate", err.Error()) - } - - req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, privateCloud) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "CreateOrUpdate", nil, "Failure preparing request") - return - } - - result, err = client.CreateOrUpdateSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "CreateOrUpdate", result.Response(), "Failure sending request") - return - } - - return -} - -// CreateOrUpdatePreparer prepares the CreateOrUpdate request. -func (client PrivateCloudsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud PrivateCloud) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - 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.AVS/privateClouds/{privateCloudName}", pathParameters), - autorest.WithJSON(privateCloud), - 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 PrivateCloudsClient) CreateOrUpdateSender(req *http.Request) (future PrivateCloudsCreateOrUpdateFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always -// closes the http.Response Body. -func (client PrivateCloudsClient) CreateOrUpdateResponder(resp *http.Response) (result PrivateCloud, 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 sends the delete request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -func (client PrivateCloudsClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string) (result PrivateCloudsDeleteFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.PrivateCloudsClient", "Delete", err.Error()) - } - - req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Delete", nil, "Failure preparing request") - return - } - - result, err = client.DeleteSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Delete", result.Response(), "Failure sending request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client PrivateCloudsClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}", 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 PrivateCloudsClient) DeleteSender(req *http.Request) (future PrivateCloudsDeleteFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client PrivateCloudsClient) 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 sends the get request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -func (client PrivateCloudsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string) (result PrivateCloud, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.PrivateCloudsClient", "Get", err.Error()) - } - - req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", nil, "Failure preparing request") - return - } - - resp, err := client.GetSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", resp, "Failure sending request") - return - } - - result, err = client.GetResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", resp, "Failure responding to request") - } - - return -} - -// GetPreparer prepares the Get request. -func (client PrivateCloudsClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}", 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 PrivateCloudsClient) 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 PrivateCloudsClient) GetResponder(resp *http.Response) (result PrivateCloud, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -// List sends the list request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -func (client PrivateCloudsClient) List(ctx context.Context, resourceGroupName string) (result PrivateCloudListPage, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.List") - defer func() { - sc := -1 - if result.pcl.Response.Response != nil { - sc = result.pcl.Response.Response.StatusCode - } - tracing.EndSpan(ctx, sc, err) - }() - } - if err := validation.Validate([]validation.Validation{ - {TargetValue: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.PrivateCloudsClient", "List", err.Error()) - } - - result.fn = client.listNextResults - req, err := client.ListPreparer(ctx, resourceGroupName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", nil, "Failure preparing request") - return - } - - resp, err := client.ListSender(req) - if err != nil { - result.pcl.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", resp, "Failure sending request") - return - } - - result.pcl, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", resp, "Failure responding to request") - } - if result.pcl.hasNextLink() && result.pcl.IsEmpty() { - err = result.NextWithContext(ctx) - } - - return -} - -// ListPreparer prepares the List request. -func (client PrivateCloudsClient) 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 = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds", 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 PrivateCloudsClient) 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 PrivateCloudsClient) ListResponder(resp *http.Response) (result PrivateCloudList, 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 PrivateCloudsClient) listNextResults(ctx context.Context, lastResults PrivateCloudList) (result PrivateCloudList, err error) { - req, err := lastResults.privateCloudListPreparer(ctx) - if err != nil { - return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "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, "avs.PrivateCloudsClient", "listNextResults", resp, "Failure sending next results request") - } - result, err = client.ListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listNextResults", resp, "Failure responding to next results request") - } - return -} - -// ListComplete enumerates all values, automatically crossing page boundaries as required. -func (client PrivateCloudsClient) ListComplete(ctx context.Context, resourceGroupName string) (result PrivateCloudListIterator, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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 -} - -// ListAdminCredentials sends the list admin credentials request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -func (client PrivateCloudsClient) ListAdminCredentials(ctx context.Context, resourceGroupName string, privateCloudName string) (result AdminCredentials, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListAdminCredentials") - 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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.PrivateCloudsClient", "ListAdminCredentials", err.Error()) - } - - req, err := client.ListAdminCredentialsPreparer(ctx, resourceGroupName, privateCloudName) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", nil, "Failure preparing request") - return - } - - resp, err := client.ListAdminCredentialsSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", resp, "Failure sending request") - return - } - - result, err = client.ListAdminCredentialsResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", resp, "Failure responding to request") - } - - return -} - -// ListAdminCredentialsPreparer prepares the ListAdminCredentials request. -func (client PrivateCloudsClient) ListAdminCredentialsPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsPost(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/listAdminCredentials", pathParameters), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ListAdminCredentialsSender sends the ListAdminCredentials request. The method will close the -// http.Response Body if it receives an error. -func (client PrivateCloudsClient) ListAdminCredentialsSender(req *http.Request) (*http.Response, error) { - return client.Send(req, azure.DoRetryWithRegistration(client.Client)) -} - -// ListAdminCredentialsResponder handles the response to the ListAdminCredentials request. The method always -// closes the http.Response Body. -func (client PrivateCloudsClient) ListAdminCredentialsResponder(resp *http.Response) (result AdminCredentials, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -// ListInSubscription sends the list in subscription request. -func (client PrivateCloudsClient) ListInSubscription(ctx context.Context) (result PrivateCloudListPage, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListInSubscription") - defer func() { - sc := -1 - if result.pcl.Response.Response != nil { - sc = result.pcl.Response.Response.StatusCode - } - tracing.EndSpan(ctx, sc, err) - }() - } - if err := validation.Validate([]validation.Validation{ - {TargetValue: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { - return result, validation.NewError("avs.PrivateCloudsClient", "ListInSubscription", err.Error()) - } - - result.fn = client.listInSubscriptionNextResults - req, err := client.ListInSubscriptionPreparer(ctx) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", nil, "Failure preparing request") - return - } - - resp, err := client.ListInSubscriptionSender(req) - if err != nil { - result.pcl.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", resp, "Failure sending request") - return - } - - result.pcl, err = client.ListInSubscriptionResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", resp, "Failure responding to request") - } - if result.pcl.hasNextLink() && result.pcl.IsEmpty() { - err = result.NextWithContext(ctx) - } - - return -} - -// ListInSubscriptionPreparer prepares the ListInSubscription request. -func (client PrivateCloudsClient) ListInSubscriptionPreparer(ctx context.Context) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - queryParameters := map[string]interface{}{ - "api-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(client.BaseURI), - autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/privateClouds", pathParameters), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ListInSubscriptionSender sends the ListInSubscription request. The method will close the -// http.Response Body if it receives an error. -func (client PrivateCloudsClient) ListInSubscriptionSender(req *http.Request) (*http.Response, error) { - return client.Send(req, azure.DoRetryWithRegistration(client.Client)) -} - -// ListInSubscriptionResponder handles the response to the ListInSubscription request. The method always -// closes the http.Response Body. -func (client PrivateCloudsClient) ListInSubscriptionResponder(resp *http.Response) (result PrivateCloudList, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -// listInSubscriptionNextResults retrieves the next set of results, if any. -func (client PrivateCloudsClient) listInSubscriptionNextResults(ctx context.Context, lastResults PrivateCloudList) (result PrivateCloudList, err error) { - req, err := lastResults.privateCloudListPreparer(ctx) - if err != nil { - return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", nil, "Failure preparing next results request") - } - if req == nil { - return - } - resp, err := client.ListInSubscriptionSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", resp, "Failure sending next results request") - } - result, err = client.ListInSubscriptionResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", resp, "Failure responding to next results request") - } - return -} - -// ListInSubscriptionComplete enumerates all values, automatically crossing page boundaries as required. -func (client PrivateCloudsClient) ListInSubscriptionComplete(ctx context.Context) (result PrivateCloudListIterator, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListInSubscription") - 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.ListInSubscription(ctx) - return -} - -// Update sends the update request. -// Parameters: -// resourceGroupName - the name of the resource group. The name is case insensitive. -// privateCloudName - name of the private cloud -// privateCloudUpdate - the private cloud properties to be updated -func (client PrivateCloudsClient) Update(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate PrivateCloudUpdate) (result PrivateCloudsUpdateFuture, err error) { - if tracing.IsEnabled() { - ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, - Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, - {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("avs.PrivateCloudsClient", "Update", err.Error()) - } - - req, err := client.UpdatePreparer(ctx, resourceGroupName, privateCloudName, privateCloudUpdate) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Update", nil, "Failure preparing request") - return - } - - result, err = client.UpdateSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Update", result.Response(), "Failure sending request") - return - } - - return -} - -// UpdatePreparer prepares the Update request. -func (client PrivateCloudsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate PrivateCloudUpdate) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "privateCloudName": autorest.Encode("path", privateCloudName), - "resourceGroupName": autorest.Encode("path", resourceGroupName), - "subscriptionId": autorest.Encode("path", client.SubscriptionID), - } - - const APIVersion = "2020-03-20" - 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.AVS/privateClouds/{privateCloudName}", pathParameters), - autorest.WithJSON(privateCloudUpdate), - 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 PrivateCloudsClient) UpdateSender(req *http.Request) (future PrivateCloudsUpdateFuture, err error) { - var resp *http.Response - resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) - if err != nil { - return - } - future.Future, err = azure.NewFutureFromResponse(resp) - return -} - -// UpdateResponder handles the response to the Update request. The method always -// closes the http.Response Body. -func (client PrivateCloudsClient) UpdateResponder(resp *http.Response) (result PrivateCloud, err error) { - err = autorest.Respond( - resp, - azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} +package avs + +// 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" +) + +// PrivateCloudsClient is the azure VMware Solution API +type PrivateCloudsClient struct { + BaseClient +} + +// NewPrivateCloudsClient creates an instance of the PrivateCloudsClient client. +func NewPrivateCloudsClient(subscriptionID string) PrivateCloudsClient { + return NewPrivateCloudsClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewPrivateCloudsClientWithBaseURI creates an instance of the PrivateCloudsClient 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 NewPrivateCloudsClientWithBaseURI(baseURI string, subscriptionID string) PrivateCloudsClient { + return PrivateCloudsClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate sends the create or update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// privateCloud - the private cloud +func (client PrivateCloudsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud PrivateCloud) (result PrivateCloudsCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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: privateCloud, + Constraints: []validation.Constraint{{Target: "privateCloud.Sku", Name: validation.Null, Rule: true, + Chain: []validation.Constraint{{Target: "privateCloud.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}, + {Target: "privateCloud.PrivateCloudProperties", Name: validation.Null, Rule: true, + Chain: []validation.Constraint{{Target: "privateCloud.PrivateCloudProperties.NetworkBlock", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { + return result, validation.NewError("avs.PrivateCloudsClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, privateCloudName, privateCloud) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client PrivateCloudsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloud PrivateCloud) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}", pathParameters), + autorest.WithJSON(privateCloud), + 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 PrivateCloudsClient) CreateOrUpdateSender(req *http.Request) (future PrivateCloudsCreateOrUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) CreateOrUpdateResponder(resp *http.Response) (result PrivateCloud, 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 sends the delete request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client PrivateCloudsClient) Delete(ctx context.Context, resourceGroupName string, privateCloudName string) (result PrivateCloudsDeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client PrivateCloudsClient) DeletePreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}", 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 PrivateCloudsClient) DeleteSender(req *http.Request) (future PrivateCloudsDeleteFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) 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 sends the get request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client PrivateCloudsClient) Get(ctx context.Context, resourceGroupName string, privateCloudName string) (result PrivateCloud, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client PrivateCloudsClient) GetPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}", 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 PrivateCloudsClient) 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 PrivateCloudsClient) GetResponder(resp *http.Response) (result PrivateCloud, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List sends the list request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +func (client PrivateCloudsClient) List(ctx context.Context, resourceGroupName string) (result PrivateCloudListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.List") + defer func() { + sc := -1 + if result.pcl.Response.Response != nil { + sc = result.pcl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, resourceGroupName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.pcl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", resp, "Failure sending request") + return + } + + result.pcl, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client PrivateCloudsClient) 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 = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds", 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 PrivateCloudsClient) 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 PrivateCloudsClient) ListResponder(resp *http.Response) (result PrivateCloudList, 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 PrivateCloudsClient) listNextResults(ctx context.Context, lastResults PrivateCloudList) (result PrivateCloudList, err error) { + req, err := lastResults.privateCloudListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "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, "avs.PrivateCloudsClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client PrivateCloudsClient) ListComplete(ctx context.Context, resourceGroupName string) (result PrivateCloudListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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 +} + +// ListAdminCredentials sends the list admin credentials request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +func (client PrivateCloudsClient) ListAdminCredentials(ctx context.Context, resourceGroupName string, privateCloudName string) (result AdminCredentials, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListAdminCredentials") + 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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "ListAdminCredentials", err.Error()) + } + + req, err := client.ListAdminCredentialsPreparer(ctx, resourceGroupName, privateCloudName) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", nil, "Failure preparing request") + return + } + + resp, err := client.ListAdminCredentialsSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", resp, "Failure sending request") + return + } + + result, err = client.ListAdminCredentialsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListAdminCredentials", resp, "Failure responding to request") + } + + return +} + +// ListAdminCredentialsPreparer prepares the ListAdminCredentials request. +func (client PrivateCloudsClient) ListAdminCredentialsPreparer(ctx context.Context, resourceGroupName string, privateCloudName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AVS/privateClouds/{privateCloudName}/listAdminCredentials", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListAdminCredentialsSender sends the ListAdminCredentials request. The method will close the +// http.Response Body if it receives an error. +func (client PrivateCloudsClient) ListAdminCredentialsSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListAdminCredentialsResponder handles the response to the ListAdminCredentials request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) ListAdminCredentialsResponder(resp *http.Response) (result AdminCredentials, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListInSubscription sends the list in subscription request. +func (client PrivateCloudsClient) ListInSubscription(ctx context.Context) (result PrivateCloudListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListInSubscription") + defer func() { + sc := -1 + if result.pcl.Response.Response != nil { + sc = result.pcl.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("avs.PrivateCloudsClient", "ListInSubscription", err.Error()) + } + + result.fn = client.listInSubscriptionNextResults + req, err := client.ListInSubscriptionPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", nil, "Failure preparing request") + return + } + + resp, err := client.ListInSubscriptionSender(req) + if err != nil { + result.pcl.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", resp, "Failure sending request") + return + } + + result.pcl, err = client.ListInSubscriptionResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "ListInSubscription", resp, "Failure responding to request") + } + + return +} + +// ListInSubscriptionPreparer prepares the ListInSubscription request. +func (client PrivateCloudsClient) ListInSubscriptionPreparer(ctx context.Context) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.AVS/privateClouds", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListInSubscriptionSender sends the ListInSubscription request. The method will close the +// http.Response Body if it receives an error. +func (client PrivateCloudsClient) ListInSubscriptionSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListInSubscriptionResponder handles the response to the ListInSubscription request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) ListInSubscriptionResponder(resp *http.Response) (result PrivateCloudList, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listInSubscriptionNextResults retrieves the next set of results, if any. +func (client PrivateCloudsClient) listInSubscriptionNextResults(ctx context.Context, lastResults PrivateCloudList) (result PrivateCloudList, err error) { + req, err := lastResults.privateCloudListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListInSubscriptionSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", resp, "Failure sending next results request") + } + result, err = client.ListInSubscriptionResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "listInSubscriptionNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListInSubscriptionComplete enumerates all values, automatically crossing page boundaries as required. +func (client PrivateCloudsClient) ListInSubscriptionComplete(ctx context.Context) (result PrivateCloudListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.ListInSubscription") + 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.ListInSubscription(ctx) + return +} + +// Update sends the update request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// privateCloudName - name of the private cloud +// privateCloudUpdate - the private cloud properties to be updated +func (client PrivateCloudsClient) Update(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate PrivateCloudUpdate) (result PrivateCloudsUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/PrivateCloudsClient.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: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {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("avs.PrivateCloudsClient", "Update", err.Error()) + } + + req, err := client.UpdatePreparer(ctx, resourceGroupName, privateCloudName, privateCloudUpdate) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Update", nil, "Failure preparing request") + return + } + + result, err = client.UpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "avs.PrivateCloudsClient", "Update", result.Response(), "Failure sending request") + return + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client PrivateCloudsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, privateCloudName string, privateCloudUpdate PrivateCloudUpdate) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "privateCloudName": autorest.Encode("path", privateCloudName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2020-03-20" + 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.AVS/privateClouds/{privateCloudName}", pathParameters), + autorest.WithJSON(privateCloudUpdate), + 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 PrivateCloudsClient) UpdateSender(req *http.Request) (future PrivateCloudsUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client PrivateCloudsClient) UpdateResponder(resp *http.Response) (result PrivateCloud, 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/avs/mgmt/2020-03-20/avs/version.go b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/version.go index 23307592c097..d683b8eba0a0 100644 --- a/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/version.go +++ b/vendor/github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs/version.go @@ -1,30 +1,30 @@ -package avs - -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() + " avs/2020-03-20" -} - -// Version returns the semantic version (see http://semver.org) of the client. -func Version() string { - return version.Number -} +package avs + +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() + " avs/2020-03-20" +} + +// 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/go-autorest/autorest/azure/environments.go b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go index 6c20b8179ab0..59823831abaa 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go @@ -81,11 +81,11 @@ var ( ManagementPortalURL: "https://manage.windowsazure.com/", PublishSettingsURL: "https://manage.windowsazure.com/publishsettings/index", ServiceManagementEndpoint: "https://management.core.windows.net/", - ResourceManagerEndpoint: "https://management.azure.com/", - ActiveDirectoryEndpoint: "https://login.microsoftonline.com/", + ResourceManagerEndpoint: "https://api-dogfood.resources.windows-int.net/", + ActiveDirectoryEndpoint: "https://login.windows-ppe.net/", GalleryEndpoint: "https://gallery.azure.com/", KeyVaultEndpoint: "https://vault.azure.net/", - GraphEndpoint: "https://graph.windows.net/", + GraphEndpoint: "https://graph.ppe.windows.net/", ServiceBusEndpoint: "https://servicebus.windows.net/", BatchManagementEndpoint: "https://batch.core.windows.net/", StorageEndpointSuffix: "core.windows.net", @@ -97,7 +97,7 @@ var ( ResourceManagerVMDNSSuffix: "cloudapp.azure.com", ContainerRegistryDNSSuffix: "azurecr.io", CosmosDBDNSSuffix: "documents.azure.com", - TokenAudience: "https://management.azure.com/", + TokenAudience: "https://management.core.windows.net/", ResourceIdentifiers: ResourceIdentifier{ Graph: "https://graph.windows.net/", KeyVault: "https://vault.azure.net", diff --git a/vendor/modules.txt b/vendor/modules.txt index 5930bdcabfda..a607417326bd 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -14,6 +14,7 @@ github.com/Azure/azure-sdk-for-go/services/apimanagement/mgmt/2019-12-01/apimana github.com/Azure/azure-sdk-for-go/services/appconfiguration/mgmt/2019-10-01/appconfiguration github.com/Azure/azure-sdk-for-go/services/appinsights/mgmt/2015-05-01/insights github.com/Azure/azure-sdk-for-go/services/automation/mgmt/2015-10-31/automation +github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs github.com/Azure/azure-sdk-for-go/services/batch/mgmt/2019-08-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 From 5d84477f7bcfd32e404e32d07addd07ddfc89b27 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Fri, 14 Aug 2020 11:15:27 +0800 Subject: [PATCH 03/23] update --- .../avs/avs_private_clouds_resource.go | 4 +-- .../tests/avs_private_clouds_resource_test.go | 30 +++++++++---------- 2 files changed, 16 insertions(+), 18 deletions(-) diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index 42e97f9cfeae..cee17e5d83c1 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -351,8 +351,6 @@ func resourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) er return fmt.Errorf("setting `identity_source`: %+v", err) } d.Set("internet_connected", props.Internet == avs.Enabled) - d.Set("nsxt_password", props.NsxtPassword) - d.Set("vcenter_password", props.VcenterPassword) d.Set("hcx_cloud_manager_endpoint", props.Endpoints.HcxCloudManager) d.Set("nsxt_manager_endpoint", props.Endpoints.NsxtManager) d.Set("vcsa_endpoint", props.Endpoints.Vcsa) @@ -435,7 +433,7 @@ func expandArmPrivateCloudIdentitySourceArray(input []interface{}) *[]avs.Identi for _, item := range input { v := item.(map[string]interface{}) sSL := avs.SslEnumDisabled - if v["ssl"].(bool) { + if v["ssl_enabled"].(bool) { sSL = avs.SslEnumEnabled } result := avs.IdentitySource{ diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 586110f8a203..3b5416f57804 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -23,7 +23,7 @@ func TestAccAzureRMavsPrivateCloud_basic(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -73,7 +73,7 @@ func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -88,7 +88,7 @@ func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep(), + data.ImportStep("nsxt_password", "vcenter_password"), }, }) } @@ -105,7 +105,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -126,7 +126,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -147,7 +147,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -168,7 +168,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -207,7 +207,7 @@ func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -228,7 +228,7 @@ func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), @@ -371,8 +371,8 @@ resource "azurerm_avs_private_cloud" "test" { username = "testUser" } internet_connected = false - nsxt_password = "PassWord1234!" - vcenter_password = "PassWord1234!" + nsxt_password = "QazWsx13$Edc" + vcenter_password = "QazWsx13$Edc" tags = { ENV = "Test" } @@ -408,8 +408,8 @@ resource "azurerm_avs_private_cloud" "test" { username = "testUser2" } internet_connected = true - nsxt_password = "PassWord1234!" - vcenter_password = "PassWord1234!" + nsxt_password = "QazWsx13$Edc" + vcenter_password = "QazWsx13$Edc" tags = { ENV = "Stage" } @@ -458,8 +458,8 @@ identity_source { username = "testUser3" } internet_connected = false - nsxt_password = "PassWord1234!" - vcenter_password = "PassWord1234!" + nsxt_password = "QazWsx13$Edc" + vcenter_password = "QazWsx13$Edc" tags = { ENV = "Test" } From cbd705ab4e48bb5815c28ad70e693bad8c3023ad Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 20 Aug 2020 09:41:45 +0800 Subject: [PATCH 04/23] update --- .../provider/required_resource_providers.go | 1 + .../avs/avs_private_clouds_data_source.go | 132 ++++++++++++- .../avs/avs_private_clouds_resource.go | 11 +- .../services/avs/parse/avs_private_clouds.go | 1 + .../avs_private_clouds_data_source_test.go | 22 ++- .../tests/avs_private_clouds_resource_test.go | 60 +++--- .../docs/d/avs_authorizations.html.markdown | 47 ----- .../website/docs/d/avs_clusters.html.markdown | 47 ----- .../d/avs_hcx_enterprise_sites.html.markdown | 47 ----- .../docs/d/avs_private_clouds.html.markdown | 48 ----- .../docs/r/avs_authorizations.html.markdown | 78 -------- .../website/docs/r/avs_clusters.html.markdown | 93 ---------- .../r/avs_hcx_enterprise_sites.html.markdown | 76 -------- .../docs/r/avs_private_clouds.html.markdown | 159 ---------------- .../autorest/azure/environments.go | 8 +- website/allowed-subcategories | 1 + website/azurerm.erb | 13 ++ .../docs/d/avs_private_cloud.html.markdown | 96 ++++++++++ .../docs/r/avs_private_cloud.html.markdown | 174 ++++++++++++++++++ 19 files changed, 478 insertions(+), 636 deletions(-) delete mode 100644 azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown delete mode 100644 azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown delete mode 100644 azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown delete mode 100644 azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown delete mode 100644 azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown delete mode 100644 azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown delete mode 100644 azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown delete mode 100644 azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown create mode 100644 website/docs/d/avs_private_cloud.html.markdown create mode 100644 website/docs/r/avs_private_cloud.html.markdown diff --git a/azurerm/internal/provider/required_resource_providers.go b/azurerm/internal/provider/required_resource_providers.go index 110cd6026774..8208ae6e0f65 100644 --- a/azurerm/internal/provider/required_resource_providers.go +++ b/azurerm/internal/provider/required_resource_providers.go @@ -20,6 +20,7 @@ func RequiredResourceProviders() map[string]struct{} { "Microsoft.AppPlatform": {}, "Microsoft.Authorization": {}, "Microsoft.Automation": {}, + "Microsoft.AVS": {}, "Microsoft.Blueprints": {}, "Microsoft.BotService": {}, "Microsoft.Cache": {}, diff --git a/azurerm/internal/services/avs/avs_private_clouds_data_source.go b/azurerm/internal/services/avs/avs_private_clouds_data_source.go index dc374d2c247e..c1cb1adedc7d 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_data_source.go +++ b/azurerm/internal/services/avs/avs_private_clouds_data_source.go @@ -2,6 +2,9 @@ package avs import ( "fmt" + "time" + + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" "github.com/hashicorp/terraform-plugin-sdk/helper/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" @@ -9,7 +12,6 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" - "time" ) func dataSourceAvsPrivateCloud() *schema.Resource { @@ -30,6 +32,115 @@ func dataSourceAvsPrivateCloud() *schema.Resource { "location": azure.SchemaLocationForDataSource(), + "sku_name": { + Type: schema.TypeString, + Computed: true, + }, + + "management_cluster": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "cluster_size": { + Type: schema.TypeInt, + Computed: true, + }, + + "cluster_id": { + Type: schema.TypeInt, + Computed: true, + }, + + "hosts": { + Type: schema.TypeSet, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + }, + }, + + "network_block": { + Type: schema.TypeString, + Computed: true, + }, + + "internet_connected": { + Type: schema.TypeBool, + Computed: true, + }, + + "circuit": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "express_route_id": { + Type: schema.TypeString, + Computed: true, + }, + + "express_route_private_peering_id": { + Type: schema.TypeString, + Computed: true, + }, + + "primary_subnet": { + Type: schema.TypeString, + Computed: true, + }, + + "secondary_subnet": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + + "hcx_cloud_manager_endpoint": { + Type: schema.TypeString, + Computed: true, + }, + + "management_network": { + Type: schema.TypeString, + Computed: true, + }, + + "nsxt_certificate_thumbprint": { + Type: schema.TypeString, + Computed: true, + }, + + "nsxt_manager_endpoint": { + Type: schema.TypeString, + Computed: true, + }, + + "provisioning_network": { + Type: schema.TypeString, + Computed: true, + }, + + "vcenter_certificate_thumbprint": { + Type: schema.TypeString, + Computed: true, + }, + + "vcsa_endpoint": { + Type: schema.TypeString, + Computed: true, + }, + + "vmotion_network": { + Type: schema.TypeString, + Computed: true, + }, + "tags": tags.SchemaDataSource(), }, } @@ -58,5 +169,24 @@ func dataSourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) d.Set("name", name) d.Set("resource_group_name", resourceGroup) d.Set("location", location.NormalizeNilable(resp.Location)) + if props := resp.PrivateCloudProperties; props != nil { + if err := d.Set("management_cluster", flattenArmPrivateCloudManagementCluster(props.ManagementCluster)); err != nil { + return fmt.Errorf("setting `management_cluster`: %+v", err) + } + d.Set("network_block", props.NetworkBlock) + if err := d.Set("circuit", flattenArmPrivateCloudCircuit(props.Circuit)); err != nil { + return fmt.Errorf("setting `circuit`: %+v", err) + } + d.Set("internet_connected", props.Internet == avs.Enabled) + d.Set("hcx_cloud_manager_endpoint", props.Endpoints.HcxCloudManager) + d.Set("nsxt_manager_endpoint", props.Endpoints.NsxtManager) + d.Set("vcsa_endpoint", props.Endpoints.Vcsa) + d.Set("management_network", props.ManagementNetwork) + d.Set("nsxt_certificate_thumbprint", props.NsxtCertificateThumbprint) + d.Set("provisioning_network", props.ProvisioningNetwork) + d.Set("vcenter_certificate_thumbprint", props.VcenterCertificateThumbprint) + d.Set("vmotion_network", props.VmotionNetwork) + } + d.Set("sku_name", resp.Sku.Name) return tags.FlattenAndSet(d, resp.Tags) } diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index cee17e5d83c1..bbf039d42c26 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -2,6 +2,9 @@ package avs import ( "fmt" + "log" + "time" + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" "github.com/hashicorp/terraform-plugin-sdk/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/helper/validation" @@ -15,8 +18,6 @@ import ( azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" - "log" - "time" ) func resourceArmAvsPrivateCloud() *schema.Resource { @@ -27,10 +28,10 @@ func resourceArmAvsPrivateCloud() *schema.Resource { Delete: resourceArmAvsPrivateCloudDelete, Timeouts: &schema.ResourceTimeout{ - Create: schema.DefaultTimeout(30 * time.Minute), + Create: schema.DefaultTimeout(240 * time.Minute), Read: schema.DefaultTimeout(5 * time.Minute), - Update: schema.DefaultTimeout(30 * time.Minute), - Delete: schema.DefaultTimeout(30 * time.Minute), + Update: schema.DefaultTimeout(240 * time.Minute), + Delete: schema.DefaultTimeout(240 * time.Minute), }, Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { diff --git a/azurerm/internal/services/avs/parse/avs_private_clouds.go b/azurerm/internal/services/avs/parse/avs_private_clouds.go index 6f0de3451d96..413dcd67c847 100644 --- a/azurerm/internal/services/avs/parse/avs_private_clouds.go +++ b/azurerm/internal/services/avs/parse/avs_private_clouds.go @@ -2,6 +2,7 @@ package parse import ( "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" ) diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go index c9e5acf2c8e6..a2ca5d628658 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_data_source_test.go @@ -2,9 +2,10 @@ package tests import ( "fmt" + "testing" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" - "testing" ) func TestAccDataSourceAzureRMavsPrivateCloud_basic(t *testing.T) { @@ -18,6 +19,23 @@ func TestAccDataSourceAzureRMavsPrivateCloud_basic(t *testing.T) { Config: testAccDataSourceavsPrivateCloud_basic(data), Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_size"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), + resource.TestCheckResourceAttrSet(data.ResourceName, "network_block"), + resource.TestCheckResourceAttrSet(data.ResourceName, "internet_connected"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), + resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), + resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, }, @@ -30,7 +48,7 @@ func testAccDataSourceavsPrivateCloud_basic(data acceptance.TestData) string { %s data "azurerm_avs_private_cloud" "test" { - name = azurerm_avs_private_cloud.test.name + name = azurerm_avs_private_cloud.test.name resource_group_name = azurerm_avs_private_cloud.test.resource_group_name } `, config) diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 3b5416f57804..b0af360f8467 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -2,13 +2,14 @@ package tests import ( "fmt" + "testing" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/terraform" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" - "testing" ) func TestAccAzureRMavsPrivateCloud_basic(t *testing.T) { @@ -317,7 +318,7 @@ resource "azurerm_avs_private_cloud" "test" { sku_name = "av36" management_cluster { - cluster_size = 4 + cluster_size = 3 } network_block = "192.168.48.0/22" } @@ -355,7 +356,7 @@ resource "azurerm_avs_private_cloud" "test" { sku_name = "AV36" management_cluster { - cluster_size = 4 + cluster_size = 3 } network_block = "192.168.48.0/22" identity_source { @@ -392,7 +393,7 @@ resource "azurerm_avs_private_cloud" "test" { sku_name = "AV36" management_cluster { - cluster_size = 3 + cluster_size = 4 } network_block = "192.168.48.0/22" identity_source { @@ -423,45 +424,46 @@ func testAccAzureRMavsPrivateCloud_updateIdentitySources(data acceptance.TestDat %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-apc-%d" resource_group_name = azurerm_resource_group.test.name - location = azurerm_resource_group.test.location - sku_name= "AV36" + location = azurerm_resource_group.test.location + sku_name = "AV36" management_cluster { - cluster_size = 4 + cluster_size = 3 } network_block = "192.168.48.0/22" identity_source { - name = "testName" - alias = "testAlias" - base_group_dn = "testGp" - base_user_dn = "testUser" - domain = "testDomain" - password = "PassWord1234!" - primary_server_url = "http://test.com" + name = "testName" + alias = "testAlias" + base_group_dn = "testGp" + base_user_dn = "testUser" + domain = "testDomain" + password = "PassWord1234!" + primary_server_url = "http://test.com" secondary_server_url = "http://test2.com" - ssl_enabled = false - username = "testUser" + ssl_enabled = false + username = "testUser" } -identity_source { - name = "testName3" - alias = "testAlias3" - base_group_dn = "testGp3" - base_user_dn = "testUser3" - domain = "testDomain3" - password = "PassWord1234!3" - primary_server_url = "http://test_secondary.com" + identity_source { + name = "testName3" + alias = "testAlias3" + base_group_dn = "testGp3" + base_user_dn = "testUser3" + domain = "testDomain3" + password = "PassWord1234!3" + primary_server_url = "http://test_secondary.com" secondary_server_url = "http://test_secondary2.com" - ssl_enabled = true - username = "testUser3" + ssl_enabled = true + username = "testUser3" } internet_connected = false - nsxt_password = "QazWsx13$Edc" - vcenter_password = "QazWsx13$Edc" + nsxt_password = "QazWsx13$Edc" + vcenter_password = "QazWsx13$Edc" tags = { ENV = "Test" } +} `, template, data.RandomInteger) } diff --git a/azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown deleted file mode 100644 index 6f2c6e9881d6..000000000000 --- a/azurerm/internal/services/avs/website/docs/d/avs_authorizations.html.markdown +++ /dev/null @@ -1,47 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: Data Source: azurerm_avs_authorization" -description: |- - Gets information about an existing avs Authorization. ---- - -# Data Source: azurerm_avs_authorization - -Use this data source to access information about an existing avs Authorization. - -## Example Usage - -```hcl -data "azurerm_avs_authorization" "example" { - name = "example-authorization" - resource_group_name = "example-resource-group" - private_cloud_name = "existing" -} - -output "id" { - value = data.azurerm_avs_authorization.example.id -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name of this avs Authorization. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs Authorization exists. - -* `private_cloud_name` - (Required) Name of the private cloud. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs Authorization. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `read` - (Defaults to 5 minutes) Used when retrieving the avs Authorization. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown deleted file mode 100644 index de1690c15cf9..000000000000 --- a/azurerm/internal/services/avs/website/docs/d/avs_clusters.html.markdown +++ /dev/null @@ -1,47 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: Data Source: azurerm_avs_cluster" -description: |- - Gets information about an existing avs Cluster. ---- - -# Data Source: azurerm_avs_cluster - -Use this data source to access information about an existing avs Cluster. - -## Example Usage - -```hcl -data "azurerm_avs_cluster" "example" { - name = "example-cluster" - resource_group_name = "example-resource-group" - private_cloud_name = "existing" -} - -output "id" { - value = data.azurerm_avs_cluster.example.id -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name of this avs Cluster. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs Cluster exists. - -* `private_cloud_name` - (Required) Name of the private cloud. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs Cluster. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `read` - (Defaults to 5 minutes) Used when retrieving the avs Cluster. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown deleted file mode 100644 index 6e18f0e9d375..000000000000 --- a/azurerm/internal/services/avs/website/docs/d/avs_hcx_enterprise_sites.html.markdown +++ /dev/null @@ -1,47 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: Data Source: azurerm_avs_hcx_enterprise_site" -description: |- - Gets information about an existing avs HcxEnterpriseSite. ---- - -# Data Source: azurerm_avs_hcx_enterprise_site - -Use this data source to access information about an existing avs HcxEnterpriseSite. - -## Example Usage - -```hcl -data "azurerm_avs_hcx_enterprise_site" "example" { - name = "example-hcxenterprisesite" - resource_group_name = "example-resource-group" - private_cloud_name = "existing" -} - -output "id" { - value = data.azurerm_avs_hcx_enterprise_site.example.id -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name of this avs HcxEnterpriseSite. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs HcxEnterpriseSite exists. - -* `private_cloud_name` - (Required) Name of the private cloud. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs HcxEnterpriseSite. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `read` - (Defaults to 5 minutes) Used when retrieving the avs HcxEnterpriseSite. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown b/azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown deleted file mode 100644 index 38b17d1338ac..000000000000 --- a/azurerm/internal/services/avs/website/docs/d/avs_private_clouds.html.markdown +++ /dev/null @@ -1,48 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: Data Source: azurerm_avs_private_cloud" -description: |- - Gets information about an existing avs PrivateCloud. ---- - -# Data Source: azurerm_avs_private_cloud - -Use this data source to access information about an existing avs PrivateCloud. - -## Example Usage - -```hcl -data "azurerm_avs_private_cloud" "example" { - name = "example-privatecloud" - resource_group_name = "example-resource-group" -} - -output "id" { - value = data.azurerm_avs_private_cloud.example.id -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name of this avs PrivateCloud. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs PrivateCloud exists. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs PrivateCloud. - -* `location` - The Azure Region where the avs PrivateCloud exists. - -* `tags` - A mapping of tags assigned to the avs PrivateCloud. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `read` - (Defaults to 5 minutes) Used when retrieving the avs PrivateCloud. \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown deleted file mode 100644 index d098815c1b57..000000000000 --- a/azurerm/internal/services/avs/website/docs/r/avs_authorizations.html.markdown +++ /dev/null @@ -1,78 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: azurerm_avs_authorization" -description: |- - Manages a avs Authorization. ---- - -# azurerm_avs_authorization - -Manages a avs Authorization. - -## Example Usage - -```hcl -resource "azurerm_resource_group" "example" { - name = "example-resources" - location = "West Europe" -} - -resource "azurerm_avs_private_cloud" "example" { - name = "example-privatecloud" - resource_group_name = azurerm_resource_group.example.name - location = azurerm_resource_group.example.location - sku { - name = "example-privatecloud" - } - - management_cluster { - cluster_size = 42 - } - network_block = "" -} - -resource "azurerm_avs_authorization" "example" { - name = "example-authorization" - resource_group_name = azurerm_resource_group.example.name - private_cloud_name = azurerm_avs_private_cloud.example.name -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name which should be used for this avs Authorization. Changing this forces a new avs Authorization to be created. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs Authorization should exist. Changing this forces a new avs Authorization to be created. - -* `private_cloud_name` - (Required) The name of the private cloud. Changing this forces a new avs Authorization to be created. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs Authorization. - -* `express_route_authorization_id` - The ID of the express_route_authorization. - -* `express_route_authorization_key` - The key of the ExpressRoute Circuit Authorization. - -* `type` - Resource type. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `create` - (Defaults to 30 minutes) Used when creating the avs Authorization. -* `read` - (Defaults to 5 minutes) Used when retrieving the avs Authorization. -* `delete` - (Defaults to 30 minutes) Used when deleting the avs Authorization. - -## Import - -avs Authorizations can be imported using the `resource id`, e.g. - -```shell -terraform import azurerm_avs_authorization.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1 -``` \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown deleted file mode 100644 index f43b6c80c88d..000000000000 --- a/azurerm/internal/services/avs/website/docs/r/avs_clusters.html.markdown +++ /dev/null @@ -1,93 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: azurerm_avs_cluster" -description: |- - Manages a avs Cluster. ---- - -# azurerm_avs_cluster - -Manages a avs Cluster. - -## Example Usage - -```hcl -resource "azurerm_resource_group" "example" { - name = "example-resources" - location = "West Europe" -} - -resource "azurerm_avs_private_cloud" "example" { - name = "example-privatecloud" - resource_group_name = azurerm_resource_group.example.name - location = azurerm_resource_group.example.location - sku { - name = "example-privatecloud" - } - - management_cluster { - cluster_size = 42 - } - network_block = "" -} - -resource "azurerm_avs_cluster" "example" { - name = "example-cluster" - resource_group_name = azurerm_resource_group.example.name - private_cloud_name = azurerm_avs_private_cloud.example.name - sku { - name = "example-cluster" - } - cluster_size = 42 -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name which should be used for this avs Cluster. Changing this forces a new avs Cluster to be created. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs Cluster should exist. Changing this forces a new avs Cluster to be created. - -* `private_cloud_name` - (Required) The name of the private cloud. Changing this forces a new avs Cluster to be created. - -* `sku` - (Required) A `sku` block as defined below. Changing this forces a new avs Cluster to be created. - -* `cluster_size` - (Required) The cluster size. - ---- - -An `sku` block exports the following: - -* `name` - (Required) The name which should be used for this sku. Changing this forces a new avs Cluster to be created. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs Cluster. - -* `cluster_id` - The ID of the cluster. - -* `hosts` - The hosts. - -* `type` - Resource type. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `create` - (Defaults to 30 minutes) Used when creating the avs Cluster. -* `read` - (Defaults to 5 minutes) Used when retrieving the avs Cluster. -* `update` - (Defaults to 30 minutes) Used when updating the avs Cluster. -* `delete` - (Defaults to 30 minutes) Used when deleting the avs Cluster. - -## Import - -avs Clusters can be imported using the `resource id`, e.g. - -```shell -terraform import azurerm_avs_cluster.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters/cluster1 -``` \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown deleted file mode 100644 index a7102f331b78..000000000000 --- a/azurerm/internal/services/avs/website/docs/r/avs_hcx_enterprise_sites.html.markdown +++ /dev/null @@ -1,76 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: azurerm_avs_hcx_enterprise_site" -description: |- - Manages a avs HcxEnterpriseSite. ---- - -# azurerm_avs_hcx_enterprise_site - -Manages a avs HcxEnterpriseSite. - -## Example Usage - -```hcl -resource "azurerm_resource_group" "example" { - name = "example-resources" - location = "West Europe" -} - -resource "azurerm_avs_private_cloud" "example" { - name = "example-privatecloud" - resource_group_name = azurerm_resource_group.example.name - location = azurerm_resource_group.example.location - sku { - name = "example-privatecloud" - } - - management_cluster { - cluster_size = 42 - } - network_block = "" -} - -resource "azurerm_avs_hcx_enterprise_site" "example" { - name = "example-hcxenterprisesite" - resource_group_name = azurerm_resource_group.example.name - private_cloud_name = azurerm_avs_private_cloud.example.name -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name which should be used for this avs HcxEnterpriseSite. Changing this forces a new avs HcxEnterpriseSite to be created. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs HcxEnterpriseSite should exist. Changing this forces a new avs HcxEnterpriseSite to be created. - -* `private_cloud_name` - (Required) The name of the private cloud. Changing this forces a new avs HcxEnterpriseSite to be created. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs HcxEnterpriseSite. - -* `activation_key` - The activation key. - -* `type` - Resource type. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `create` - (Defaults to 30 minutes) Used when creating the avs HcxEnterpriseSite. -* `read` - (Defaults to 5 minutes) Used when retrieving the avs HcxEnterpriseSite. -* `delete` - (Defaults to 30 minutes) Used when deleting the avs HcxEnterpriseSite. - -## Import - -avs HcxEnterpriseSites can be imported using the `resource id`, e.g. - -```shell -terraform import azurerm_avs_hcx_enterprise_site.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/hcxEnterpriseSites/hcxEnterpriseSite1 -``` \ No newline at end of file diff --git a/azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown b/azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown deleted file mode 100644 index 099ec120d789..000000000000 --- a/azurerm/internal/services/avs/website/docs/r/avs_private_clouds.html.markdown +++ /dev/null @@ -1,159 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: azurerm_avs_private_cloud" -description: |- - Manages a avs PrivateCloud. ---- - -# azurerm_avs_private_cloud - -Manages a avs PrivateCloud. - -## Example Usage - -```hcl -resource "azurerm_resource_group" "example" { - name = "example-resources" - location = "West Europe" -} - -resource "azurerm_avs_private_cloud" "example" { - name = "example-privatecloud" - resource_group_name = azurerm_resource_group.example.name - location = azurerm_resource_group.example.location - sku { - name = "example-privatecloud" - } - - management_cluster { - cluster_size = 42 - } - network_block = "192.168.48.0/22" -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name which should be used for this avs PrivateCloud. Changing this forces a new avs PrivateCloud to be created. - -* `resource_group_name` - (Required) The name of the Resource Group where the avs PrivateCloud should exist. Changing this forces a new avs PrivateCloud to be created. - -* `location` - (Required) The Azure Region where the avs PrivateCloud should exist. Changing this forces a new avs PrivateCloud to be created. - -* `sku` - (Required) A `sku` block as defined below. Changing this forces a new avs PrivateCloud to be created. - -* `management_cluster` - (Required) A `management_cluster` block as defined below. - -* `network_block` - (Required) The block of addresses should be unique across VNet in your subscription as well as on-premise. Make sure the CIDR format is conformed to (A.B.C.D/X) where A,B,C,D are between 0 and 255, and X is between 0 and 22. - ---- - -* `identity_source` - (Optional) A `identity_source` block as defined below. - -* `internet` - (Optional) Connectivity to internet is enabled or disabled. Possible values are "true" and "false" is allowed. - -* `nsxt_password` - (Optional) Optionally, set the NSX-T Manager password when the private cloud is created. - -* `vcenter_password` - (Optional) Optionally, set the vCenter admin password when the private cloud is created. - -* `tags` - (Optional) A mapping of tags which should be assigned to the avs PrivateCloud. - ---- - -An `sku` block exports the following: - -* `name` - (Required) The name which should be used for this sku. Changing this forces a new avs PrivateCloud to be created. - ---- - -An `management_cluster` block exports the following: - -* `cluster_size` - (Required) The cluster size. - ---- - -An `identity_source` block exports the following: - -* `name` - (Optional) The name which should be used for this identity_source. - -* `alias` - (Optional) The domain's NetBIOS name. - -* `base_group_dn` - (Optional) The base distinguished name for groups. - -* `base_user_dn` - (Optional) The base distinguished name for users. - -* `domain` - (Optional) The domain's dns name. - -* `password` - (Optional) The password of the Active Directory user with a minimum of read-only access to Base DN for users and groups. - -* `primary_server` - (Optional) Primary server URL. - -* `secondary_server` - (Optional) Secondary server URL. - -* `ssl` - (Optional) Protect LDAP communication using SSL certificate (LDAPS). Possible values are "true" and "false" is allowed. - -* `username` - (Optional) The ID of an Active Directory user with a minimum of read-only access to Base DN for users and group. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the avs PrivateCloud. - -* `circuit` - An ExpressRoute Circuit. A `circuit` block as defined below. - -* `endpoint` - The endpoints. A `endpoint` block as defined below. - -* `management_network` - Network used to access vCenter Server and NSX-T Manager. - -* `nsxt_certificate_thumbprint` - Thumbprint of the NSX-T Manager SSL certificate. - -* `provisioning_network` - Used for virtual machine cold migration, cloning, and snapshot migration. - -* `type` - Resource type. - -* `vcenter_certificate_thumbprint` - Thumbprint of the vCenter Server SSL certificate. - -* `vmotion_network` - Used for live migration of virtual machines. - ---- - -An `circuit` block exports the following: - -* `express_route_id` - The ID of the express_route. - -* `express_route_private_peering_id` - The ID of the express_route_private_peering. - -* `primary_subnet` - CIDR of primary subnet. - -* `secondary_subnet` - CIDR of secondary subnet. - ---- - -An `endpoint` block exports the following: - -* `hcx_cloud_manager` - Endpoint for the HCX Cloud Manager. - -* `nsxt_manager` - Endpoint for the NSX-T Data Center manager. - -* `vcsa` - Endpoint for Virtual Center Server Appliance. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `create` - (Defaults to 30 minutes) Used when creating the avs PrivateCloud. -* `read` - (Defaults to 5 minutes) Used when retrieving the avs PrivateCloud. -* `update` - (Defaults to 30 minutes) Used when updating the avs PrivateCloud. -* `delete` - (Defaults to 30 minutes) Used when deleting the avs PrivateCloud. - -## Import - -avs PrivateClouds can be imported using the `resource id`, e.g. - -```shell -terraform import azurerm_avs_private_cloud.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1 -``` \ No newline at end of file diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go index 59823831abaa..6c20b8179ab0 100644 --- a/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go +++ b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go @@ -81,11 +81,11 @@ var ( ManagementPortalURL: "https://manage.windowsazure.com/", PublishSettingsURL: "https://manage.windowsazure.com/publishsettings/index", ServiceManagementEndpoint: "https://management.core.windows.net/", - ResourceManagerEndpoint: "https://api-dogfood.resources.windows-int.net/", - ActiveDirectoryEndpoint: "https://login.windows-ppe.net/", + ResourceManagerEndpoint: "https://management.azure.com/", + ActiveDirectoryEndpoint: "https://login.microsoftonline.com/", GalleryEndpoint: "https://gallery.azure.com/", KeyVaultEndpoint: "https://vault.azure.net/", - GraphEndpoint: "https://graph.ppe.windows.net/", + GraphEndpoint: "https://graph.windows.net/", ServiceBusEndpoint: "https://servicebus.windows.net/", BatchManagementEndpoint: "https://batch.core.windows.net/", StorageEndpointSuffix: "core.windows.net", @@ -97,7 +97,7 @@ var ( ResourceManagerVMDNSSuffix: "cloudapp.azure.com", ContainerRegistryDNSSuffix: "azurecr.io", CosmosDBDNSSuffix: "documents.azure.com", - TokenAudience: "https://management.core.windows.net/", + TokenAudience: "https://management.azure.com/", ResourceIdentifiers: ResourceIdentifier{ Graph: "https://graph.windows.net/", KeyVault: "https://vault.azure.net", diff --git a/website/allowed-subcategories b/website/allowed-subcategories index f0a9bf2a674e..2a95ad9a037f 100644 --- a/website/allowed-subcategories +++ b/website/allowed-subcategories @@ -6,6 +6,7 @@ App Service (Web Apps) Application Insights Authorization Automation +Avs Base Batch Blueprints diff --git a/website/azurerm.erb b/website/azurerm.erb index c21c580df7cc..c4552b74172f 100644 --- a/website/azurerm.erb +++ b/website/azurerm.erb @@ -137,6 +137,10 @@ azurerm_availability_set +
  • + azurerm_avs_private_cloud +
    • +
  • azurerm_backup_policy_vm
    • @@ -992,6 +996,15 @@ +
  • + Azure Vmware Solution Resources + +
    • +
  • Backup Resources
      diff --git a/website/docs/d/avs_private_cloud.html.markdown b/website/docs/d/avs_private_cloud.html.markdown new file mode 100644 index 000000000000..e6c14fa584f5 --- /dev/null +++ b/website/docs/d/avs_private_cloud.html.markdown @@ -0,0 +1,96 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: Data Source: azurerm_avs_private_cloud" +description: |- + Gets information about an existing Azure Vmware Solution Private Cloud. +--- + +# Data Source: azurerm_avs_private_cloud + +Use this data source to access information about an existing Azure Vmware Solution Private Cloud. + +## Example Usage + +```hcl +data "azurerm_avs_private_cloud" "example" { + name = "existing-avs-private-cloud" + resource_group_name = "existing-resgroup" +} + +output "id" { + value = data.azurerm_avs_private_cloud.example.id +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name of this Azure Vmware Solution Private Cloud. + +* `resource_group_name` - (Required) The name of the Resource Group where the Azure Vmware Solution Private Cloud exists. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the Azure Vmware Solution Private Cloud. + +* `location` - The Azure Region where the Azure Vmware Solution Private Cloud exists. + +* `circuit` - A `circuit` block as defined below. + +* `internet_connected` - Is connected to the internet? + +* `management_cluster` - A `management_cluster` block as defined below. + +* `network_block` - The block of addresses which should be unique across virtual network in your subscription as well as on-premise. + +* `hcx_cloud_manager_endpoint` - The endpoint for the HCX Cloud Manager. + +* `nsxt_manager_endpoint` - The endpoint for the NSX-T Data Center manager. + +* `vcsa_endpoint` - The endpoint for Virtual Center Server Appliance. + +* `sku_name` - The name of the SKU. + +* `nsxt_certificate_thumbprint` - The thumbprint of the NSX-T Manager SSL certificate. + +* `vcenter_certificate_thumbprint` - The thumbprint of the vCenter Server SSL certificate. + +* `management_network` - The network used to access vCenter Server and NSX-T Manager. + +* `provisioning_network` - The network which isused for virtual machine cold migration, cloning, and snapshot migration. + +* `vmotion_network` - The network which is used for live migration of virtual machines. + +* `tags` - A mapping of tags assigned to the Azure Vmware Solution Private Cloud. + +--- + +A `circuit` block exports the following: + +* `express_route_id` - The ID of the ExpressRoute Circuit. + +* `express_route_private_peering_id` - The ID of the ExpressRoute Circuit private peering. + +* `primary_subnet` - The CIDR of primary subnet. + +* `secondary_subnet` - The CIDR of secondary subnet. + +--- + +A `management_cluster` block exports the following: + +* `cluster_id` - The ID of the cluster. + +* `cluster_size` - The size of the cluster. + +* `hosts` - The set of the hosts in the cluster. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `read` - (Defaults to 5 minutes) Used when retrieving the Azure Vmware Solution Private Cloud. diff --git a/website/docs/r/avs_private_cloud.html.markdown b/website/docs/r/avs_private_cloud.html.markdown new file mode 100644 index 000000000000..80d784070b19 --- /dev/null +++ b/website/docs/r/avs_private_cloud.html.markdown @@ -0,0 +1,174 @@ +--- +subcategory: "Avs" +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_avs_private_cloud" +description: |- + Manages a Azure Vmware Solution Private Cloud. +--- + +# azurerm_avs_private_cloud + +Manages a Azure Vmware Solution Private Cloud. + +## Example Usage + +```hcl +provider "azurerm" { + features {} +} + +resource "azurerm_resource_group" "example" { + name = "example-resources" + location = "West Europe" +} + +resource "azurerm_avs_private_cloud" "example" { + name = "example-avs-private-cloud" + resource_group_name = azurerm_resource_group.example.name + location = azurerm_resource_group.example.location + sku_name = "AV36" + + management_cluster { + cluster_size = 3 + } + + network_block = "192.168.48.0/22" + + identity_source { + name = "exampleName" + alias = "exampleAlias" + base_group_dn = "exampleGp" + base_user_dn = "exampleUser" + domain = "exampleDomain" + password = "PassWord1234!" + primary_server_url = "http://example.com" + secondary_server_url = "http://example2.com" + ssl_enabled = false + username = "exampleUser" + } + + internet_connected = false + nsxt_password = "QazWsx13$Edc" + vcenter_password = "QazWsx13$Edc" + tags = { + foo = "bar" + } +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name which should be used for this Azure Vmware Solution Private Cloud. Changing this forces a new Azure Vmware Solution Private Cloud to be created. + +* `resource_group_name` - (Required) The name of the Resource Group where the Azure Vmware Solution Private Cloud should exist. Changing this forces a new Azure Vmware Solution Private Cloud to be created. + +* `location` - (Required) The Azure Region where the Azure Vmware Solution Private Cloud should exist. Changing this forces a new Azure Vmware Solution Private Cloud to be created. + +* `management_cluster` - (Required) A `management_cluster` block as defined below. + +* `network_block` - (Required) The block of addresses which should be unique across virtual network in your subscription as well as on-premise. Changing this forces a new Azure Vmware Solution Private Cloud to be created. + +* `sku_name` - (Required) The name of the SKU. Changing this forces a new Azure Vmware Solution Private Cloud to be created. Possible values are "av20", "av36" and "av36t". + +* `identity_source` - (Optional) One or more `identity_source` blocks as defined below. + +* `internet_connected` - (Optional) Is connected to the internet? + +* `nsxt_password` - (Optional) The password of the NSX-T Manager. Changing this forces a new Azure Vmware Solution Private Cloud to be created. + +* `vcenter_password` - (Optional) The password of the vCenter admin. Changing this forces a new Azure Vmware Solution Private Cloud to be created. + +* `tags` - (Optional) A mapping of tags which should be assigned to the Azure Vmware Solution Private Cloud. + +--- + +A `identity_source` block supports the following: + +* `name` - (Required) The name of the identity source + +* `alias` - (Required) The domain's NetBIOS name. + +* `base_group_dn` - (Required) The base distinguished name for groups. + +* `base_user_dn` - (Required) The base distinguished name for users. + +* `domain` - (Required) The domain's dns name. + +* `primary_server_url` - (Required) The primary server URL. + +* `secondary_server_url` - (Optional) The secondary server URL. + +* `ssl_enabled` - (Required) Should we protect LDAP communication using SSL certificate (LDAPS)? + +* `username` - (Required) The ID of an Active Directory user with a minimum of read-only access to Base DN for users and group. + +* `password` - (Required) The password of the Active Directory user with a minimum of read-only access to Base DN for users and groups. + +--- + +A `management_cluster` block supports the following: + +* `cluster_size` - (Required) The size of the cluster. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the Azure Vmware Solution Private Cloud. + +* `circuit` - A `circuit` block as defined below. + +* `hcx_cloud_manager_endpoint` - The endpoint for the HCX Cloud Manager. + +* `nsxt_manager_endpoint` - The endpoint for the NSX-T Data Center manager. + +* `vcsa_endpoint` - The endpoint for Virtual Center Server Appliance. + +* `nsxt_certificate_thumbprint` - The thumbprint of the NSX-T Manager SSL certificate. + +* `vcenter_certificate_thumbprint` - The thumbprint of the vCenter Server SSL certificate. + +* `management_network` - The network used to access vCenter Server and NSX-T Manager. + +* `provisioning_network` - The network which isused for virtual machine cold migration, cloning, and snapshot migration. + +* `vmotion_network` - The network which is used for live migration of virtual machines. + +--- + +A `circuit` block exports the following: + +* `express_route_id` - The ID of the ExpressRoute Circuit. + +* `express_route_private_peering_id` - The ID of the ExpressRoute Circuit private peering. + +* `primary_subnet` - The CIDR of primary subnet. + +* `secondary_subnet` - The CIDR of secondary subnet. + +--- + +A `management_cluster` block exports the following: + +* `cluster_id` - The ID of the cluster. + +* `hosts` - The set of the hosts in the cluster. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `create` - (Defaults to 1 hour and 30 minutes) Used when creating the Azure Vmware Solution Private Cloud. +* `read` - (Defaults to 5 minutes) Used when retrieving the Azure Vmware Solution Private Cloud. +* `update` - (Defaults to 1 hour and 30 minutes) Used when updating the Azure Vmware Solution Private Cloud. +* `delete` - (Defaults to 1 hour and 30 minutes) Used when deleting the Azure Vmware Solution Private Cloud. + +## Import + +Azure Vmware Solution Private Clouds can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_avs_private_cloud.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/PrivateClouds/privateCloud1 +``` From 72141960a4d5112684ebf925f8f001a35894a2b1 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 20 Aug 2020 13:43:56 +0800 Subject: [PATCH 05/23] updat --- .../tests/avs_private_clouds_resource_test.go | 98 +++++++++---------- 1 file changed, 44 insertions(+), 54 deletions(-) diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index b0af360f8467..83a91562bd0e 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -101,27 +101,6 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { Providers: acceptance.SupportedProviders, CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_basic(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), - ), - }, - data.ImportStep(), { Config: testAccAzureRMavsPrivateCloud_complete(data), Check: resource.ComposeTestCheckFunc( @@ -142,7 +121,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep(), + data.ImportStep("nsxt_password", "vcenter_password"), { Config: testAccAzureRMavsPrivateCloud_update(data), Check: resource.ComposeTestCheckFunc( @@ -163,9 +142,20 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep(), + data.ImportStep("nsxt_password", "vcenter_password"), + }, + }) +} + +func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, + Steps: []resource.TestStep{ { - Config: testAccAzureRMavsPrivateCloud_basic(data), + Config: testAccAzureRMavsPrivateCloud_withoutIdentitySources(data), Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), @@ -184,25 +174,14 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep(), - }, - }) -} - -func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ + data.ImportStep("nsxt_password", "vcenter_password"), { Config: testAccAzureRMavsPrivateCloud_complete(data), Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), ), }, - data.ImportStep(), + data.ImportStep("nsxt_password", "vcenter_password"), { Config: testAccAzureRMavsPrivateCloud_updateIdentitySources(data), Check: resource.ComposeTestCheckFunc( @@ -223,28 +202,14 @@ func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep(), + data.ImportStep("nsxt_password", "vcenter_password"), { - Config: testAccAzureRMavsPrivateCloud_basic(data), + Config: testAccAzureRMavsPrivateCloud_withoutIdentitySources(data), Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep(), + data.ImportStep("nsxt_password", "vcenter_password"), }, }) } @@ -467,3 +432,28 @@ resource "azurerm_avs_private_cloud" "test" { } `, template, data.RandomInteger) } + +func testAccAzureRMavsPrivateCloud_withoutIdentitySources(data acceptance.TestData) string { + template := testAccAzureRMavsPrivateCloud_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + sku_name = "AV36" + + management_cluster { + cluster_size = 3 + } + network_block = "192.168.48.0/22" + internet_connected = false + nsxt_password = "QazWsx13$Edc" + vcenter_password = "QazWsx13$Edc" + tags = { + ENV = "Test" + } +} +`, template, data.RandomInteger) +} From bfb5b155fee132955a401afe93079e92c17e7aa9 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 20 Aug 2020 14:41:05 +0800 Subject: [PATCH 06/23] update --- .../avs/tests/avs_private_clouds_resource_test.go | 10 +++++----- website/docs/r/avs_private_cloud.html.markdown | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 83a91562bd0e..21a890951f91 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -14,7 +14,7 @@ import ( func TestAccAzureRMavsPrivateCloud_basic(t *testing.T) { data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ + resource.Test(t, resource.TestCase{ PreCheck: func() { acceptance.PreCheck(t) }, Providers: acceptance.SupportedProviders, CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, @@ -46,7 +46,7 @@ func TestAccAzureRMavsPrivateCloud_basic(t *testing.T) { func TestAccAzureRMavsPrivateCloud_requiresImport(t *testing.T) { data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ + resource.Test(t, resource.TestCase{ PreCheck: func() { acceptance.PreCheck(t) }, Providers: acceptance.SupportedProviders, CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, @@ -64,7 +64,7 @@ func TestAccAzureRMavsPrivateCloud_requiresImport(t *testing.T) { func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ + resource.Test(t, resource.TestCase{ PreCheck: func() { acceptance.PreCheck(t) }, Providers: acceptance.SupportedProviders, CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, @@ -96,7 +96,7 @@ func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ + resource.Test(t, resource.TestCase{ PreCheck: func() { acceptance.PreCheck(t) }, Providers: acceptance.SupportedProviders, CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, @@ -149,7 +149,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.ParallelTest(t, resource.TestCase{ + resource.Test(t, resource.TestCase{ PreCheck: func() { acceptance.PreCheck(t) }, Providers: acceptance.SupportedProviders, CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, diff --git a/website/docs/r/avs_private_cloud.html.markdown b/website/docs/r/avs_private_cloud.html.markdown index 80d784070b19..559f08874d33 100644 --- a/website/docs/r/avs_private_cloud.html.markdown +++ b/website/docs/r/avs_private_cloud.html.markdown @@ -160,10 +160,10 @@ A `management_cluster` block exports the following: The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: -* `create` - (Defaults to 1 hour and 30 minutes) Used when creating the Azure Vmware Solution Private Cloud. +* `create` - (Defaults to 4 hours) Used when creating the Azure Vmware Solution Private Cloud. * `read` - (Defaults to 5 minutes) Used when retrieving the Azure Vmware Solution Private Cloud. -* `update` - (Defaults to 1 hour and 30 minutes) Used when updating the Azure Vmware Solution Private Cloud. -* `delete` - (Defaults to 1 hour and 30 minutes) Used when deleting the Azure Vmware Solution Private Cloud. +* `update` - (Defaults to 4 hours) Used when updating the Azure Vmware Solution Private Cloud. +* `delete` - (Defaults to 4 hours) Used when deleting the Azure Vmware Solution Private Cloud. ## Import From 8296b399c906dfa1bb5a4d0adb1e4b447580b3f5 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Wed, 26 Aug 2020 09:51:24 +0800 Subject: [PATCH 07/23] remove identity --- .../internal/services/avs/avs_private_clouds_resource.go | 6 +++--- .../services/avs/tests/avs_private_clouds_resource_test.go | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index bbf039d42c26..fc1da6ff380e 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -348,9 +348,9 @@ func resourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) er if err := d.Set("circuit", flattenArmPrivateCloudCircuit(props.Circuit)); err != nil { return fmt.Errorf("setting `circuit`: %+v", err) } - if err := d.Set("identity_source", flattenArmPrivateCloudIdentitySourceArray(props.IdentitySources)); err != nil { - return fmt.Errorf("setting `identity_source`: %+v", err) - } + //if err := d.Set("identity_source", flattenArmPrivateCloudIdentitySourceArray(props.IdentitySources)); err != nil { + // return fmt.Errorf("setting `identity_source`: %+v", err) + //} d.Set("internet_connected", props.Internet == avs.Enabled) d.Set("hcx_cloud_manager_endpoint", props.Endpoints.HcxCloudManager) d.Set("nsxt_manager_endpoint", props.Endpoints.NsxtManager) diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 21a890951f91..9aaeb3271d4f 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -89,7 +89,7 @@ func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep("nsxt_password", "vcenter_password"), + data.ImportStep("nsxt_password", "vcenter_password", "identity_source.#", "identity_source.0.alias", "identity_source.0.base_group_dn", "identity_source.0.base_user_dn", "identity_source.0.domain", "identity_source.0.name", "identity_source.0.password", "identity_source.0.primary_server_url", "identity_source.0.secondary_server_url", "identity_source.0.ssl_enabled", "identity_source.0.username"), }, }) } @@ -121,7 +121,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep("nsxt_password", "vcenter_password"), + data.ImportStep("nsxt_password", "vcenter_password", "identity_source.#", "identity_source.0.alias", "identity_source.0.base_group_dn", "identity_source.0.base_user_dn", "identity_source.0.domain", "identity_source.0.name", "identity_source.0.password", "identity_source.0.primary_server_url", "identity_source.0.secondary_server_url", "identity_source.0.ssl_enabled", "identity_source.0.username"), { Config: testAccAzureRMavsPrivateCloud_update(data), Check: resource.ComposeTestCheckFunc( @@ -142,7 +142,7 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep("nsxt_password", "vcenter_password"), + data.ImportStep("nsxt_password", "vcenter_password", "identity_source.#", "identity_source.0.alias", "identity_source.0.base_group_dn", "identity_source.0.base_user_dn", "identity_source.0.domain", "identity_source.0.name", "identity_source.0.password", "identity_source.0.primary_server_url", "identity_source.0.secondary_server_url", "identity_source.0.ssl_enabled", "identity_source.0.username"), }, }) } From 63a6467f52323d410e88b43a205fc90e98ae6cb3 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Mon, 7 Sep 2020 10:19:12 +0800 Subject: [PATCH 08/23] update --- .../avs/avs_private_clouds_resource.go | 162 +---------------- .../tests/avs_private_clouds_resource_test.go | 170 +----------------- 2 files changed, 4 insertions(+), 328 deletions(-) diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index fc1da6ff380e..182ffcce2a20 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -97,73 +97,6 @@ func resourceArmAvsPrivateCloud() *schema.Resource { ValidateFunc: validation.IsCIDR, }, - "identity_source": { - Type: schema.TypeSet, - Optional: true, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringIsNotEmpty, - }, - - "alias": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringIsNotEmpty, - }, - - "base_group_dn": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringIsNotEmpty, - }, - - "base_user_dn": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringIsNotEmpty, - }, - - "domain": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringIsNotEmpty, - }, - - "password": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringIsNotEmpty, - }, - - "primary_server_url": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.IsURLWithHTTPorHTTPS, - }, - - "secondary_server_url": { - Type: schema.TypeString, - Optional: true, - ValidateFunc: validation.IsURLWithHTTPorHTTPS, - }, - - "ssl_enabled": { - Type: schema.TypeBool, - Required: true, - }, - - "username": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringIsNotEmpty, - }, - }, - }, - }, - "internet_connected": { Type: schema.TypeBool, Optional: true, @@ -289,7 +222,6 @@ func resourceArmAvsPrivateCloudCreate(d *schema.ResourceData, meta interface{}) ClusterSize: utils.Int32(int32(d.Get("management_cluster.0.cluster_size").(int))), }, NetworkBlock: utils.String(d.Get("network_block").(string)), - IdentitySources: expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()), Internet: internet, NsxtPassword: utils.String(d.Get("nsxt_password").(string)), VcenterPassword: utils.String(d.Get("vcenter_password").(string)), @@ -348,9 +280,7 @@ func resourceArmAvsPrivateCloudRead(d *schema.ResourceData, meta interface{}) er if err := d.Set("circuit", flattenArmPrivateCloudCircuit(props.Circuit)); err != nil { return fmt.Errorf("setting `circuit`: %+v", err) } - //if err := d.Set("identity_source", flattenArmPrivateCloudIdentitySourceArray(props.IdentitySources)); err != nil { - // return fmt.Errorf("setting `identity_source`: %+v", err) - //} + d.Set("internet_connected", props.Internet == avs.Enabled) d.Set("hcx_cloud_manager_endpoint", props.Endpoints.HcxCloudManager) d.Set("nsxt_manager_endpoint", props.Endpoints.NsxtManager) @@ -390,9 +320,7 @@ func resourceArmAvsPrivateCloudUpdate(d *schema.ResourceData, meta interface{}) } privateCloudUpdate.PrivateCloudUpdateProperties.Internet = internet } - if d.HasChange("identity_source") { - privateCloudUpdate.PrivateCloudUpdateProperties.IdentitySources = expandArmPrivateCloudIdentitySourceArray(d.Get("identity_source").(*schema.Set).List()) - } + if d.HasChange("tags") { privateCloudUpdate.Tags = tags.Expand(d.Get("tags").(map[string]interface{})) } @@ -429,31 +357,6 @@ func resourceArmAvsPrivateCloudDelete(d *schema.ResourceData, meta interface{}) return nil } -func expandArmPrivateCloudIdentitySourceArray(input []interface{}) *[]avs.IdentitySource { - results := make([]avs.IdentitySource, 0) - for _, item := range input { - v := item.(map[string]interface{}) - sSL := avs.SslEnumDisabled - if v["ssl_enabled"].(bool) { - sSL = avs.SslEnumEnabled - } - result := avs.IdentitySource{ - Name: utils.String(v["name"].(string)), - Alias: utils.String(v["alias"].(string)), - Domain: utils.String(v["domain"].(string)), - BaseUserDN: utils.String(v["base_user_dn"].(string)), - BaseGroupDN: utils.String(v["base_group_dn"].(string)), - PrimaryServer: utils.String(v["primary_server_url"].(string)), - SecondaryServer: utils.String(v["secondary_server_url"].(string)), - Ssl: sSL, - Username: utils.String(v["username"].(string)), - Password: utils.String(v["password"].(string)), - } - results = append(results, result) - } - return &results -} - func flattenArmPrivateCloudManagementCluster(input *avs.ManagementCluster) []interface{} { if input == nil { return make([]interface{}, 0) @@ -506,64 +409,3 @@ func flattenArmPrivateCloudCircuit(input *avs.Circuit) []interface{} { }, } } - -func flattenArmPrivateCloudIdentitySourceArray(input *[]avs.IdentitySource) []interface{} { - results := make([]interface{}, 0) - if input == nil { - return results - } - - for _, item := range *input { - var name string - if item.Name != nil { - name = *item.Name - } - var alias string - if item.Alias != nil { - alias = *item.Alias - } - var baseGroupDn string - if item.BaseGroupDN != nil { - baseGroupDn = *item.BaseGroupDN - } - var baseUserDn string - if item.BaseUserDN != nil { - baseUserDn = *item.BaseUserDN - } - var domain string - if item.Domain != nil { - domain = *item.Domain - } - var password string - if item.Password != nil { - password = *item.Password - } - var primaryServer string - if item.PrimaryServer != nil { - primaryServer = *item.PrimaryServer - } - var secondaryServer string - if item.SecondaryServer != nil { - secondaryServer = *item.SecondaryServer - } - sSL := item.Ssl == avs.SslEnumEnabled - var username string - if item.Username != nil { - username = *item.Username - } - v := map[string]interface{}{ - "name": name, - "alias": alias, - "base_group_dn": baseGroupDn, - "base_user_dn": baseUserDn, - "domain": domain, - "password": password, - "primary_server_url": primaryServer, - "secondary_server_url": secondaryServer, - "ssl_enabled": sSL, - "username": username, - } - results = append(results, v) - } - return results -} diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 9aaeb3271d4f..9ad2c92f0a25 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -89,7 +89,7 @@ func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep("nsxt_password", "vcenter_password", "identity_source.#", "identity_source.0.alias", "identity_source.0.base_group_dn", "identity_source.0.base_user_dn", "identity_source.0.domain", "identity_source.0.name", "identity_source.0.password", "identity_source.0.primary_server_url", "identity_source.0.secondary_server_url", "identity_source.0.ssl_enabled", "identity_source.0.username"), + data.ImportStep("nsxt_password", "vcenter_password"), }, }) } @@ -121,69 +121,9 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), ), }, - data.ImportStep("nsxt_password", "vcenter_password", "identity_source.#", "identity_source.0.alias", "identity_source.0.base_group_dn", "identity_source.0.base_user_dn", "identity_source.0.domain", "identity_source.0.name", "identity_source.0.password", "identity_source.0.primary_server_url", "identity_source.0.secondary_server_url", "identity_source.0.ssl_enabled", "identity_source.0.username"), - { - Config: testAccAzureRMavsPrivateCloud_update(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), - ), - }, - data.ImportStep("nsxt_password", "vcenter_password", "identity_source.#", "identity_source.0.alias", "identity_source.0.base_group_dn", "identity_source.0.base_user_dn", "identity_source.0.domain", "identity_source.0.name", "identity_source.0.password", "identity_source.0.primary_server_url", "identity_source.0.secondary_server_url", "identity_source.0.ssl_enabled", "identity_source.0.username"), - }, - }) -} - -func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_avs_private_cloud", "test") - resource.Test(t, resource.TestCase{ - PreCheck: func() { acceptance.PreCheck(t) }, - Providers: acceptance.SupportedProviders, - CheckDestroy: testCheckAzureRMavsPrivateCloudDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAzureRMavsPrivateCloud_withoutIdentitySources(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.hosts.#"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.express_route_private_peering_id"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.primary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "circuit.0.secondary_subnet"), - resource.TestCheckResourceAttrSet(data.ResourceName, "hcx_cloud_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "management_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "nsxt_manager_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "provisioning_network"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcenter_certificate_thumbprint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vcsa_endpoint"), - resource.TestCheckResourceAttrSet(data.ResourceName, "vmotion_network"), - ), - }, - data.ImportStep("nsxt_password", "vcenter_password"), - { - Config: testAccAzureRMavsPrivateCloud_complete(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, data.ImportStep("nsxt_password", "vcenter_password"), { - Config: testAccAzureRMavsPrivateCloud_updateIdentitySources(data), + Config: testAccAzureRMavsPrivateCloud_update(data), Check: resource.ComposeTestCheckFunc( testCheckAzureRMavsPrivateCloudExists(data.ResourceName), resource.TestCheckResourceAttrSet(data.ResourceName, "management_cluster.0.cluster_id"), @@ -203,13 +143,6 @@ func TestAccAzureRMavsPrivateCloud_updateIdentitySources(t *testing.T) { ), }, data.ImportStep("nsxt_password", "vcenter_password"), - { - Config: testAccAzureRMavsPrivateCloud_withoutIdentitySources(data), - Check: resource.ComposeTestCheckFunc( - testCheckAzureRMavsPrivateCloudExists(data.ResourceName), - ), - }, - data.ImportStep("nsxt_password", "vcenter_password"), }, }) } @@ -324,18 +257,6 @@ resource "azurerm_avs_private_cloud" "test" { cluster_size = 3 } network_block = "192.168.48.0/22" - identity_source { - name = "testName" - alias = "testAlias" - base_group_dn = "testGp" - base_user_dn = "testUser" - domain = "testDomain" - password = "PassWord1234!" - primary_server_url = "http://test.com" - secondary_server_url = "http://test2.com" - ssl_enabled = false - username = "testUser" - } internet_connected = false nsxt_password = "QazWsx13$Edc" vcenter_password = "QazWsx13$Edc" @@ -361,18 +282,6 @@ resource "azurerm_avs_private_cloud" "test" { cluster_size = 4 } network_block = "192.168.48.0/22" - identity_source { - name = "testName2" - alias = "testAlias2" - base_group_dn = "testGp2" - base_user_dn = "testUser2" - domain = "testDomain2" - password = "PassWord1234!2" - primary_server_url = "http://test_secondary.com" - secondary_server_url = "http://test_secondary2.com" - ssl_enabled = true - username = "testUser2" - } internet_connected = true nsxt_password = "QazWsx13$Edc" vcenter_password = "QazWsx13$Edc" @@ -382,78 +291,3 @@ resource "azurerm_avs_private_cloud" "test" { } `, template, data.RandomInteger) } - -func testAccAzureRMavsPrivateCloud_updateIdentitySources(data acceptance.TestData) string { - template := testAccAzureRMavsPrivateCloud_template(data) - return fmt.Sprintf(` -%s - -resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" - resource_group_name = azurerm_resource_group.test.name - location = azurerm_resource_group.test.location - sku_name = "AV36" - - management_cluster { - cluster_size = 3 - } - network_block = "192.168.48.0/22" - identity_source { - name = "testName" - alias = "testAlias" - base_group_dn = "testGp" - base_user_dn = "testUser" - domain = "testDomain" - password = "PassWord1234!" - primary_server_url = "http://test.com" - secondary_server_url = "http://test2.com" - ssl_enabled = false - username = "testUser" - } - - identity_source { - name = "testName3" - alias = "testAlias3" - base_group_dn = "testGp3" - base_user_dn = "testUser3" - domain = "testDomain3" - password = "PassWord1234!3" - primary_server_url = "http://test_secondary.com" - secondary_server_url = "http://test_secondary2.com" - ssl_enabled = true - username = "testUser3" - } - internet_connected = false - nsxt_password = "QazWsx13$Edc" - vcenter_password = "QazWsx13$Edc" - tags = { - ENV = "Test" - } -} -`, template, data.RandomInteger) -} - -func testAccAzureRMavsPrivateCloud_withoutIdentitySources(data acceptance.TestData) string { - template := testAccAzureRMavsPrivateCloud_template(data) - return fmt.Sprintf(` -%s - -resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" - resource_group_name = azurerm_resource_group.test.name - location = azurerm_resource_group.test.location - sku_name = "AV36" - - management_cluster { - cluster_size = 3 - } - network_block = "192.168.48.0/22" - internet_connected = false - nsxt_password = "QazWsx13$Edc" - vcenter_password = "QazWsx13$Edc" - tags = { - ENV = "Test" - } -} -`, template, data.RandomInteger) -} From 2ca144af7d5d7a6276fffa6e6c408005eb031343 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 10 Sep 2020 14:32:17 +0800 Subject: [PATCH 09/23] update --- .../avs/avs_private_clouds_resource.go | 41 +++++++++++++++++-- 1 file changed, 37 insertions(+), 4 deletions(-) diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index 182ffcce2a20..476855e70f03 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -1,8 +1,11 @@ package avs import ( + "context" "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" "log" + "strconv" "time" "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" @@ -346,17 +349,47 @@ func resourceArmAvsPrivateCloudDelete(d *schema.ResourceData, meta interface{}) return err } - future, err := client.Delete(ctx, id.ResourceGroup, id.Name) - if err != nil { + if _, err = client.Delete(ctx, id.ResourceGroup, id.Name); err != nil { return fmt.Errorf("deleting Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) } - if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { - return fmt.Errorf("waiting on deleting future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) + return waitForAvsPrivateCloudToBeDeleted(ctx, client, id.ResourceGroup, id.Name, d) +} + +func waitForAvsPrivateCloudToBeDeleted(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string, d *schema.ResourceData) error { + // we can't use the Waiter here since the API returns status succeed once it's deleted which is considered a polling status code.. + log.Printf("[DEBUG] Waiting for Avs Private Cloud %q in Resource Group %q to be deleted", name, resourceGroup) + stateConf := &resource.StateChangeConf{ + Pending: []string{"200"}, + Target: []string{"404"}, + Refresh: avsPrivateCloudStateStatusCodeRefreshFunc(ctx, client, resourceGroup, name), + Timeout: d.Timeout(schema.TimeoutDelete), } + + if _, err := stateConf.WaitForState(); err != nil { + return fmt.Errorf("waiting for Avs Private Cloud %q in Resource Group %q to be deleted: %+v", name, resourceGroup, err) + } + return nil } +func avsPrivateCloudStateStatusCodeRefreshFunc(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string) resource.StateRefreshFunc { + return func() (interface{}, string, error) { + res, err := client.Get(ctx, resourceGroup, name) + + log.Printf("retrieving Avs Private Cloud %q in Resource Group %q returned Status %d", resourceGroup, name, res.StatusCode) + + if err != nil { + if utils.ResponseWasNotFound(res.Response) { + return res, strconv.Itoa(res.StatusCode), nil + } + return nil, "", fmt.Errorf("polling for the status of the Avs Private Cloud %q (RG: %q): %+v", name, resourceGroup, err) + } + + return res, strconv.Itoa(res.StatusCode), nil + } +} + func flattenArmPrivateCloudManagementCluster(input *avs.ManagementCluster) []interface{} { if input == nil { return make([]interface{}, 0) From 4a1393037159ac194e5a8c751d8b209c4904ab28 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Mon, 14 Sep 2020 11:30:29 +0800 Subject: [PATCH 10/23] update --- .teamcity/components/generated/services.kt | 1 + .../services/avs/avs_clusters_resource.go | 218 ++++++++++++++++++ .../avs/avs_private_clouds_resource.go | 74 +++--- .../internal/services/avs/client/client.go | 5 + .../services/avs/parse/avs_clusters.go | 34 +++ .../services/avs/parse/avs_clusters_test.go | 77 +++++++ azurerm/internal/services/avs/registration.go | 1 + .../avs/tests/avs_clusters_resource_test.go | 191 +++++++++++++++ .../tests/avs_private_clouds_resource_test.go | 10 +- 9 files changed, 570 insertions(+), 41 deletions(-) create mode 100644 azurerm/internal/services/avs/avs_clusters_resource.go create mode 100644 azurerm/internal/services/avs/parse/avs_clusters.go create mode 100644 azurerm/internal/services/avs/parse/avs_clusters_test.go create mode 100644 azurerm/internal/services/avs/tests/avs_clusters_resource_test.go diff --git a/.teamcity/components/generated/services.kt b/.teamcity/components/generated/services.kt index 69be66a697d0..95a26c7e04d0 100644 --- a/.teamcity/components/generated/services.kt +++ b/.teamcity/components/generated/services.kt @@ -9,6 +9,7 @@ var services = mapOf( "applicationinsights" to "Application Insights", "authorization" to "Authorization", "automation" to "Automation", + "avs" to "Avs", "batch" to "Batch", "blueprints" to "Blueprints", "bot" to "Bot", diff --git a/azurerm/internal/services/avs/avs_clusters_resource.go b/azurerm/internal/services/avs/avs_clusters_resource.go new file mode 100644 index 000000000000..85cb336680d3 --- /dev/null +++ b/azurerm/internal/services/avs/avs_clusters_resource.go @@ -0,0 +1,218 @@ +package avs + +import ( + "fmt" + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/helper/validation" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/suppress" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "log" + "time" +) + +func resourceArmAvsCluster() *schema.Resource { + return &schema.Resource{ + Create: resourceArmAvsClusterCreate, + Read: resourceArmAvsClusterRead, + Update: resourceArmAvsClusterUpdate, + Delete: resourceArmAvsClusterDelete, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(240 * time.Minute), + Read: schema.DefaultTimeout(5 * time.Minute), + Update: schema.DefaultTimeout(240 * time.Minute), + Delete: schema.DefaultTimeout(240 * time.Minute), + }, + + Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { + _, err := parse.AvsClusterID(id) + return err + }), + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "private_cloud_id": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "cluster_size": { + Type: schema.TypeInt, + Required: true, + }, + + "sku_name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{ + "av20", + "av36", + "av36t", + }, true), + DiffSuppressFunc: suppress.CaseDifference, + }, + + "cluster_id": { + Type: schema.TypeInt, + Computed: true, + }, + + "hosts": { + Type: schema.TypeSet, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + } +} +func resourceArmAvsClusterCreate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) + defer cancel() + + name := d.Get("name").(string) + privateCloudId, _ := parse.AvsPrivateCloudID(d.Get("private_cloud_id").(string)) + + existing, err := client.Get(ctx, privateCloudId.ResourceGroup, privateCloudId.Name, name) + if err != nil { + if !utils.ResponseWasNotFound(existing.Response) { + return fmt.Errorf("checking for present of existing Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + } + if existing.ID != nil && *existing.ID != "" { + return tf.ImportAsExistsError("azurerm_avs_cluster", *existing.ID) + } + + cluster := avs.Cluster{ + Sku: &avs.Sku{ + Name: utils.String(d.Get("sku_name").(string)), + }, + ClusterProperties: &avs.ClusterProperties{ + ClusterSize: utils.Int32(int32(d.Get("cluster_size").(int))), + }, + } + future, err := client.CreateOrUpdate(ctx, privateCloudId.ResourceGroup, privateCloudId.Name, name, cluster) + if err != nil { + return fmt.Errorf("creating Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on creating future for Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + + resp, err := client.Get(ctx, privateCloudId.ResourceGroup, privateCloudId.Name, name) + if err != nil { + return fmt.Errorf("retrieving Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + + if resp.ID == nil || *resp.ID == "" { + return fmt.Errorf("empty or nil ID returned for Avs Cluster %q (Resource Group %q / privateCloudName %q) ID", name, privateCloudId.ResourceGroup, privateCloudId.Name) + } + + d.SetId(*resp.ID) + return resourceArmAvsClusterRead(d, meta) +} + +func resourceArmAvsClusterRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + pcClient := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsClusterID(d.Id()) + if err != nil { + return err + } + + resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + log.Printf("[INFO] avs %q does not exist - removing from state", d.Id()) + d.SetId("") + return nil + } + return fmt.Errorf("retrieving Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + + pcResp, err := pcClient.Get(ctx, id.ResourceGroup, id.PrivateCloudName) + if err != nil { + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", id.PrivateCloudName, id.ResourceGroup, err) + } + + if pcResp.ID == nil || *pcResp.ID == "" { + return fmt.Errorf("avs PrivateCloud %q (Resource Group %q) ID is empty or nil", id.PrivateCloudName, id.ResourceGroup) + } + d.Set("name", id.Name) + d.Set("private_cloud_id", pcResp.ID) + d.Set("sku_name", resp.Sku.Name) + if props := resp.ClusterProperties; props != nil { + d.Set("cluster_size", props.ClusterSize) + d.Set("cluster_id", props.ClusterID) + d.Set("hosts", utils.FlattenStringSlice(props.Hosts)) + } + return nil +} + +func resourceArmAvsClusterUpdate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsClusterID(d.Id()) + if err != nil { + return err + } + + clusterUpdate := avs.ClusterUpdate{ + ClusterUpdateProperties: &avs.ClusterUpdateProperties{}, + } + if d.HasChange("cluster_size") { + clusterUpdate.ClusterUpdateProperties.ClusterSize = utils.Int32(int32(d.Get("cluster_size").(int))) + } + + future, err := client.Update(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name, clusterUpdate) + if err != nil { + return fmt.Errorf("updating Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on updating future for Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + return resourceArmAvsClusterRead(d, meta) +} + +func resourceArmAvsClusterDelete(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsClusterID(d.Id()) + if err != nil { + return err + } + + future, err := client.Delete(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + if err != nil { + return fmt.Errorf("deleting Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on deleting future for Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + return nil +} diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index 476855e70f03..2bfa8769cf73 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -1,11 +1,8 @@ package avs import ( - "context" "fmt" - "github.com/hashicorp/terraform-plugin-sdk/helper/resource" "log" - "strconv" "time" "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" @@ -349,46 +346,51 @@ func resourceArmAvsPrivateCloudDelete(d *schema.ResourceData, meta interface{}) return err } - if _, err = client.Delete(ctx, id.ResourceGroup, id.Name); err != nil { + future, err := client.Delete(ctx, id.ResourceGroup, id.Name) + if err != nil { return fmt.Errorf("deleting Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) } - return waitForAvsPrivateCloudToBeDeleted(ctx, client, id.ResourceGroup, id.Name, d) -} - -func waitForAvsPrivateCloudToBeDeleted(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string, d *schema.ResourceData) error { - // we can't use the Waiter here since the API returns status succeed once it's deleted which is considered a polling status code.. - log.Printf("[DEBUG] Waiting for Avs Private Cloud %q in Resource Group %q to be deleted", name, resourceGroup) - stateConf := &resource.StateChangeConf{ - Pending: []string{"200"}, - Target: []string{"404"}, - Refresh: avsPrivateCloudStateStatusCodeRefreshFunc(ctx, client, resourceGroup, name), - Timeout: d.Timeout(schema.TimeoutDelete), - } - - if _, err := stateConf.WaitForState(); err != nil { - return fmt.Errorf("waiting for Avs Private Cloud %q in Resource Group %q to be deleted: %+v", name, resourceGroup, err) + if err = future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting for deleting Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) } - return nil + //return waitForAvsPrivateCloudToBeDeleted(ctx, client, id.ResourceGroup, id.Name, d) } -func avsPrivateCloudStateStatusCodeRefreshFunc(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string) resource.StateRefreshFunc { - return func() (interface{}, string, error) { - res, err := client.Get(ctx, resourceGroup, name) - - log.Printf("retrieving Avs Private Cloud %q in Resource Group %q returned Status %d", resourceGroup, name, res.StatusCode) - - if err != nil { - if utils.ResponseWasNotFound(res.Response) { - return res, strconv.Itoa(res.StatusCode), nil - } - return nil, "", fmt.Errorf("polling for the status of the Avs Private Cloud %q (RG: %q): %+v", name, resourceGroup, err) - } - - return res, strconv.Itoa(res.StatusCode), nil - } -} +//func waitForAvsPrivateCloudToBeDeleted(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string, d *schema.ResourceData) error { +// // we can't use the Waiter here since the API returns status succeed once it's deleted which is considered a polling status code.. +// log.Printf("[DEBUG] Waiting for Avs Private Cloud %q in Resource Group %q to be deleted", name, resourceGroup) +// stateConf := &resource.StateChangeConf{ +// Pending: []string{"200"}, +// Target: []string{"404"}, +// Refresh: avsPrivateCloudStateStatusCodeRefreshFunc(ctx, client, resourceGroup, name), +// Timeout: d.Timeout(schema.TimeoutDelete), +// } +// +// if _, err := stateConf.WaitForState(); err != nil { +// return fmt.Errorf("waiting for Avs Private Cloud %q in Resource Group %q to be deleted: %+v", name, resourceGroup, err) +// } +// +// return nil +//} +// +//func avsPrivateCloudStateStatusCodeRefreshFunc(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string) resource.StateRefreshFunc { +// return func() (interface{}, string, error) { +// res, err := client.Get(ctx, resourceGroup, name) +// +// log.Printf("retrieving Avs Private Cloud %q in Resource Group %q returned Status %d", resourceGroup, name, res.StatusCode) +// +// if err != nil { +// if utils.ResponseWasNotFound(res.Response) { +// return res, strconv.Itoa(res.StatusCode), nil +// } +// return nil, "", fmt.Errorf("polling for the status of the Avs Private Cloud %q (RG: %q): %+v", name, resourceGroup, err) +// } +// +// return res, strconv.Itoa(res.StatusCode), nil +// } +//} func flattenArmPrivateCloudManagementCluster(input *avs.ManagementCluster) []interface{} { if input == nil { diff --git a/azurerm/internal/services/avs/client/client.go b/azurerm/internal/services/avs/client/client.go index ca0362e7231b..07532c5f5e12 100644 --- a/azurerm/internal/services/avs/client/client.go +++ b/azurerm/internal/services/avs/client/client.go @@ -7,13 +7,18 @@ import ( type Client struct { PrivateCloudClient *avs.PrivateCloudsClient + ClusterClient *avs.ClustersClient } func NewClient(o *common.ClientOptions) *Client { privateCloudClient := avs.NewPrivateCloudsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) o.ConfigureClient(&privateCloudClient.Client, o.ResourceManagerAuthorizer) + clusterClient := avs.NewClustersClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&clusterClient.Client, o.ResourceManagerAuthorizer) + return &Client{ PrivateCloudClient: &privateCloudClient, + ClusterClient: &clusterClient, } } diff --git a/azurerm/internal/services/avs/parse/avs_clusters.go b/azurerm/internal/services/avs/parse/avs_clusters.go new file mode 100644 index 000000000000..7aac683ab97e --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_clusters.go @@ -0,0 +1,34 @@ +package parse + +import ( + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) + +type AvsClusterId struct { + ResourceGroup string + PrivateCloudName string + Name string +} + +func AvsClusterID(input string) (*AvsClusterId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsCluster ID %q: %+v", input, err) + } + + avsCluster := AvsClusterId{ + ResourceGroup: id.ResourceGroup, + } + if avsCluster.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if avsCluster.Name, err = id.PopSegment("clusters"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &avsCluster, nil +} diff --git a/azurerm/internal/services/avs/parse/avs_clusters_test.go b/azurerm/internal/services/avs/parse/avs_clusters_test.go new file mode 100644 index 000000000000..eaf40698c48b --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_clusters_test.go @@ -0,0 +1,77 @@ +package parse + +import ( + "testing" +) + +func TestAvsClusterID(t *testing.T) { + testData := []struct { + Name string + Input string + Expected *AvsClusterId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing Cluster Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters", + Expected: nil, + }, + { + Name: "avs Cluster ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters/cluster1", + Expected: &AvsClusterId{ + ResourceGroup: "resourceGroup1", + PrivateCloudName: "privateCloud1", + Name: "cluster1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/Clusters/cluster1", + Expected: nil, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) + + actual, err := AvsClusterID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } + + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + + if actual.PrivateCloudName != v.Expected.PrivateCloudName { + t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) + } + + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/avs/registration.go b/azurerm/internal/services/avs/registration.go index f6d02a09485a..83e2c68b460d 100644 --- a/azurerm/internal/services/avs/registration.go +++ b/azurerm/internal/services/avs/registration.go @@ -27,5 +27,6 @@ func (r Registration) SupportedDataSources() map[string]*schema.Resource { func (r Registration) SupportedResources() map[string]*schema.Resource { return map[string]*schema.Resource{ "azurerm_avs_private_cloud": resourceArmAvsPrivateCloud(), + "azurerm_avs_cluster": resourceArmAvsCluster(), } } diff --git a/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go b/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go new file mode 100644 index 000000000000..c0414fc85924 --- /dev/null +++ b/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go @@ -0,0 +1,191 @@ +package tests + +import ( + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "testing" +) + +func TestAccAzureRMavsCluster_basic(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_cluster", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsClusterDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func TestAccAzureRMavsCluster_requiresImport(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_cluster", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsClusterDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.RequiresImportErrorStep(testAccAzureRMavsCluster_requiresImport), + }, + }) +} + +func TestAccAzureRMavsCluster_update(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_cluster", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsClusterDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsCluster_update(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func testCheckAzureRMavsClusterExists(resourceName string) resource.TestCheckFunc { + return func(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.ClusterClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("avs Cluster not found: %s", resourceName) + } + id, err := parse.AvsClusterID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Avs Cluster %q does not exist", id.Name) + } + return fmt.Errorf("bad: Get on Avs.ClusterClient: %+v", err) + } + return nil + } +} + +func testCheckAzureRMavsClusterDestroy(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.ClusterClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + + for _, rs := range s.RootModule().Resources { + if rs.Type != "azurerm_avs_cluster" { + continue + } + id, err := parse.AvsClusterID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Get on Avs.ClusterClient: %+v", err) + } + } + return nil + } + return nil +} + +func testAccAzureRMavsCluster_template(data acceptance.TestData) string { + return fmt.Sprintf(` +provider "azurerm" { + features {} +} + +resource "azurerm_resource_group" "test" { + name = "acctest-avs-%[1]d" + location = "%[2]s" +} + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%[1]d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + sku_name = "av36" + + management_cluster { + cluster_size = 3 + } + network_block = "192.168.48.0/22" +} +`, data.RandomInteger, data.Locations.Primary) +} + +func testAccAzureRMavsCluster_basic(data acceptance.TestData) string { + template := testAccAzureRMavsCluster_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_cluster" "test" { + name = "acctest-ac-%d" + private_cloud_id = azurerm_avs_private_cloud.test.id + cluster_size = 3 + sku_name = "av36t" +} +`, template, data.RandomInteger) +} + +func testAccAzureRMavsCluster_requiresImport(data acceptance.TestData) string { + config := testAccAzureRMavsCluster_basic(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_cluster" "import" { + name = azurerm_avs_cluster.test.name + private_cloud_id = azurerm_avs_cluster.test.private_cloud_id + cluster_size = azurerm_avs_cluster.test.cluster_size + sku_name = azurerm_avs_cluster.test.sku_name +} +`, config) +} + +func testAccAzureRMavsCluster_update(data acceptance.TestData) string { + template := testAccAzureRMavsCluster_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_cluster" "test" { + name = "acctest-ac-%d" + private_cloud_name = azurerm_avs_private_cloud.test.id + cluster_size = 4 + sku_name = "av36t" +} +`, template, data.RandomInteger) +} diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 9ad2c92f0a25..1428e7ee30ae 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -210,7 +210,7 @@ func testAccAzureRMavsPrivateCloud_basic(data acceptance.TestData) string { %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-APC-%d" resource_group_name = azurerm_resource_group.test.name location = azurerm_resource_group.test.location sku_name = "av36" @@ -248,7 +248,7 @@ func testAccAzureRMavsPrivateCloud_complete(data acceptance.TestData) string { %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-APC-%d" resource_group_name = azurerm_resource_group.test.name location = azurerm_resource_group.test.location sku_name = "AV36" @@ -256,7 +256,7 @@ resource "azurerm_avs_private_cloud" "test" { management_cluster { cluster_size = 3 } - network_block = "192.168.48.0/22" + network_block = "192.168.48.0/22" internet_connected = false nsxt_password = "QazWsx13$Edc" vcenter_password = "QazWsx13$Edc" @@ -273,7 +273,7 @@ func testAccAzureRMavsPrivateCloud_update(data acceptance.TestData) string { %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-APC-%d" resource_group_name = azurerm_resource_group.test.name location = azurerm_resource_group.test.location sku_name = "AV36" @@ -281,7 +281,7 @@ resource "azurerm_avs_private_cloud" "test" { management_cluster { cluster_size = 4 } - network_block = "192.168.48.0/22" + network_block = "192.168.48.0/22" internet_connected = true nsxt_password = "QazWsx13$Edc" vcenter_password = "QazWsx13$Edc" From 641eb8486660067bcf091182bbf186d0d461c89b Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 17 Sep 2020 14:22:51 +0800 Subject: [PATCH 11/23] update --- .../avs/avs_private_clouds_resource.go | 72 ++++++++++--------- .../tests/avs_private_clouds_resource_test.go | 21 +++++- 2 files changed, 56 insertions(+), 37 deletions(-) diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index 476855e70f03..75ed12f9f477 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -1,11 +1,8 @@ package avs import ( - "context" "fmt" - "github.com/hashicorp/terraform-plugin-sdk/helper/resource" "log" - "strconv" "time" "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" @@ -349,46 +346,51 @@ func resourceArmAvsPrivateCloudDelete(d *schema.ResourceData, meta interface{}) return err } - if _, err = client.Delete(ctx, id.ResourceGroup, id.Name); err != nil { + future, err := client.Delete(ctx, id.ResourceGroup, id.Name) + if err != nil { return fmt.Errorf("deleting Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) } - return waitForAvsPrivateCloudToBeDeleted(ctx, client, id.ResourceGroup, id.Name, d) -} - -func waitForAvsPrivateCloudToBeDeleted(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string, d *schema.ResourceData) error { - // we can't use the Waiter here since the API returns status succeed once it's deleted which is considered a polling status code.. - log.Printf("[DEBUG] Waiting for Avs Private Cloud %q in Resource Group %q to be deleted", name, resourceGroup) - stateConf := &resource.StateChangeConf{ - Pending: []string{"200"}, - Target: []string{"404"}, - Refresh: avsPrivateCloudStateStatusCodeRefreshFunc(ctx, client, resourceGroup, name), - Timeout: d.Timeout(schema.TimeoutDelete), - } - - if _, err := stateConf.WaitForState(); err != nil { - return fmt.Errorf("waiting for Avs Private Cloud %q in Resource Group %q to be deleted: %+v", name, resourceGroup, err) + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on deleting future for Avs PrivateCloud %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err) } return nil } -func avsPrivateCloudStateStatusCodeRefreshFunc(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string) resource.StateRefreshFunc { - return func() (interface{}, string, error) { - res, err := client.Get(ctx, resourceGroup, name) - - log.Printf("retrieving Avs Private Cloud %q in Resource Group %q returned Status %d", resourceGroup, name, res.StatusCode) - - if err != nil { - if utils.ResponseWasNotFound(res.Response) { - return res, strconv.Itoa(res.StatusCode), nil - } - return nil, "", fmt.Errorf("polling for the status of the Avs Private Cloud %q (RG: %q): %+v", name, resourceGroup, err) - } - - return res, strconv.Itoa(res.StatusCode), nil - } -} +//func waitForAvsPrivateCloudToBeDeleted(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string, d *schema.ResourceData) error { +// // we can't use the Waiter here since the API returns status succeed once it's deleted which is considered a polling status code.. +// log.Printf("[DEBUG] Waiting for Avs Private Cloud %q in Resource Group %q to be deleted", name, resourceGroup) +// stateConf := &resource.StateChangeConf{ +// Pending: []string{"200"}, +// Target: []string{"404"}, +// Refresh: avsPrivateCloudStateStatusCodeRefreshFunc(ctx, client, resourceGroup, name), +// Timeout: d.Timeout(schema.TimeoutDelete), +// } +// +// if _, err := stateConf.WaitForState(); err != nil { +// return fmt.Errorf("waiting for Avs Private Cloud %q in Resource Group %q to be deleted: %+v", name, resourceGroup, err) +// } +// +// return nil +//} +// +//func avsPrivateCloudStateStatusCodeRefreshFunc(ctx context.Context, client *avs.PrivateCloudsClient, resourceGroup, name string) resource.StateRefreshFunc { +// return func() (interface{}, string, error) { +// res, err := client.Get(ctx, resourceGroup, name) +// +// log.Printf("retrieving Avs Private Cloud %q in Resource Group %q returned Status %d", resourceGroup, name, res.StatusCode) +// +// if err != nil { +// if utils.ResponseWasNotFound(res.Response) { +// return res, strconv.Itoa(res.StatusCode), nil +// } +// return nil, "", fmt.Errorf("polling for the status of the Avs Private Cloud %q (RG: %q): %+v", name, resourceGroup, err) +// } +// +// return res, strconv.Itoa(res.StatusCode), nil +// } +//} func flattenArmPrivateCloudManagementCluster(input *avs.ManagementCluster) []interface{} { if input == nil { diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 9ad2c92f0a25..6ce7bdf9fc66 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -3,6 +3,7 @@ package tests import ( "fmt" "testing" + "time" "github.com/hashicorp/terraform-plugin-sdk/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/terraform" @@ -40,6 +41,10 @@ func TestAccAzureRMavsPrivateCloud_basic(t *testing.T) { ), }, data.ImportStep(), + { + PreConfig: func() { time.Sleep(17 * time.Minute) }, + Config: testAccAzureRMavsPrivateCloud_basic(data), + }, }, }) } @@ -58,6 +63,10 @@ func TestAccAzureRMavsPrivateCloud_requiresImport(t *testing.T) { ), }, data.RequiresImportErrorStep(testAccAzureRMavsPrivateCloud_requiresImport), + { + PreConfig: func() { time.Sleep(17 * time.Minute) }, + Config: testAccAzureRMavsPrivateCloud_requiresImport(data), + }, }, }) } @@ -90,6 +99,10 @@ func TestAccAzureRMavsPrivateCloud_complete(t *testing.T) { ), }, data.ImportStep("nsxt_password", "vcenter_password"), + { + PreConfig: func() { time.Sleep(17 * time.Minute) }, + Config: testAccAzureRMavsPrivateCloud_complete(data), + }, }, }) } @@ -143,6 +156,10 @@ func TestAccAzureRMavsPrivateCloud_update(t *testing.T) { ), }, data.ImportStep("nsxt_password", "vcenter_password"), + { + PreConfig: func() { time.Sleep(17 * time.Minute) }, + Config: testAccAzureRMavsPrivateCloud_update(data), + }, }, }) } @@ -256,7 +273,7 @@ resource "azurerm_avs_private_cloud" "test" { management_cluster { cluster_size = 3 } - network_block = "192.168.48.0/22" + network_block = "192.168.48.0/22" internet_connected = false nsxt_password = "QazWsx13$Edc" vcenter_password = "QazWsx13$Edc" @@ -281,7 +298,7 @@ resource "azurerm_avs_private_cloud" "test" { management_cluster { cluster_size = 4 } - network_block = "192.168.48.0/22" + network_block = "192.168.48.0/22" internet_connected = true nsxt_password = "QazWsx13$Edc" vcenter_password = "QazWsx13$Edc" From ccb752fa08c58c40a5cf652700da459944c8d1a9 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 17 Sep 2020 14:24:30 +0800 Subject: [PATCH 12/23] rebase --- .teamcity/components/generated/services.kt | 1 + .../services/avs/avs_clusters_resource.go | 218 ++++++++++++++++++ .../internal/services/avs/client/client.go | 5 + .../services/avs/parse/avs_clusters.go | 34 +++ .../services/avs/parse/avs_clusters_test.go | 77 +++++++ azurerm/internal/services/avs/registration.go | 1 + .../avs/tests/avs_clusters_resource_test.go | 191 +++++++++++++++ .../tests/avs_private_clouds_resource_test.go | 6 +- 8 files changed, 530 insertions(+), 3 deletions(-) create mode 100644 azurerm/internal/services/avs/avs_clusters_resource.go create mode 100644 azurerm/internal/services/avs/parse/avs_clusters.go create mode 100644 azurerm/internal/services/avs/parse/avs_clusters_test.go create mode 100644 azurerm/internal/services/avs/tests/avs_clusters_resource_test.go diff --git a/.teamcity/components/generated/services.kt b/.teamcity/components/generated/services.kt index 69be66a697d0..95a26c7e04d0 100644 --- a/.teamcity/components/generated/services.kt +++ b/.teamcity/components/generated/services.kt @@ -9,6 +9,7 @@ var services = mapOf( "applicationinsights" to "Application Insights", "authorization" to "Authorization", "automation" to "Automation", + "avs" to "Avs", "batch" to "Batch", "blueprints" to "Blueprints", "bot" to "Bot", diff --git a/azurerm/internal/services/avs/avs_clusters_resource.go b/azurerm/internal/services/avs/avs_clusters_resource.go new file mode 100644 index 000000000000..85cb336680d3 --- /dev/null +++ b/azurerm/internal/services/avs/avs_clusters_resource.go @@ -0,0 +1,218 @@ +package avs + +import ( + "fmt" + "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/helper/validation" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/suppress" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "log" + "time" +) + +func resourceArmAvsCluster() *schema.Resource { + return &schema.Resource{ + Create: resourceArmAvsClusterCreate, + Read: resourceArmAvsClusterRead, + Update: resourceArmAvsClusterUpdate, + Delete: resourceArmAvsClusterDelete, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(240 * time.Minute), + Read: schema.DefaultTimeout(5 * time.Minute), + Update: schema.DefaultTimeout(240 * time.Minute), + Delete: schema.DefaultTimeout(240 * time.Minute), + }, + + Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { + _, err := parse.AvsClusterID(id) + return err + }), + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "private_cloud_id": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "cluster_size": { + Type: schema.TypeInt, + Required: true, + }, + + "sku_name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{ + "av20", + "av36", + "av36t", + }, true), + DiffSuppressFunc: suppress.CaseDifference, + }, + + "cluster_id": { + Type: schema.TypeInt, + Computed: true, + }, + + "hosts": { + Type: schema.TypeSet, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + } +} +func resourceArmAvsClusterCreate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) + defer cancel() + + name := d.Get("name").(string) + privateCloudId, _ := parse.AvsPrivateCloudID(d.Get("private_cloud_id").(string)) + + existing, err := client.Get(ctx, privateCloudId.ResourceGroup, privateCloudId.Name, name) + if err != nil { + if !utils.ResponseWasNotFound(existing.Response) { + return fmt.Errorf("checking for present of existing Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + } + if existing.ID != nil && *existing.ID != "" { + return tf.ImportAsExistsError("azurerm_avs_cluster", *existing.ID) + } + + cluster := avs.Cluster{ + Sku: &avs.Sku{ + Name: utils.String(d.Get("sku_name").(string)), + }, + ClusterProperties: &avs.ClusterProperties{ + ClusterSize: utils.Int32(int32(d.Get("cluster_size").(int))), + }, + } + future, err := client.CreateOrUpdate(ctx, privateCloudId.ResourceGroup, privateCloudId.Name, name, cluster) + if err != nil { + return fmt.Errorf("creating Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on creating future for Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + + resp, err := client.Get(ctx, privateCloudId.ResourceGroup, privateCloudId.Name, name) + if err != nil { + return fmt.Errorf("retrieving Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", name, privateCloudId.ResourceGroup, privateCloudId.Name, err) + } + + if resp.ID == nil || *resp.ID == "" { + return fmt.Errorf("empty or nil ID returned for Avs Cluster %q (Resource Group %q / privateCloudName %q) ID", name, privateCloudId.ResourceGroup, privateCloudId.Name) + } + + d.SetId(*resp.ID) + return resourceArmAvsClusterRead(d, meta) +} + +func resourceArmAvsClusterRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + pcClient := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsClusterID(d.Id()) + if err != nil { + return err + } + + resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + log.Printf("[INFO] avs %q does not exist - removing from state", d.Id()) + d.SetId("") + return nil + } + return fmt.Errorf("retrieving Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + + pcResp, err := pcClient.Get(ctx, id.ResourceGroup, id.PrivateCloudName) + if err != nil { + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", id.PrivateCloudName, id.ResourceGroup, err) + } + + if pcResp.ID == nil || *pcResp.ID == "" { + return fmt.Errorf("avs PrivateCloud %q (Resource Group %q) ID is empty or nil", id.PrivateCloudName, id.ResourceGroup) + } + d.Set("name", id.Name) + d.Set("private_cloud_id", pcResp.ID) + d.Set("sku_name", resp.Sku.Name) + if props := resp.ClusterProperties; props != nil { + d.Set("cluster_size", props.ClusterSize) + d.Set("cluster_id", props.ClusterID) + d.Set("hosts", utils.FlattenStringSlice(props.Hosts)) + } + return nil +} + +func resourceArmAvsClusterUpdate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + ctx, cancel := timeouts.ForUpdate(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsClusterID(d.Id()) + if err != nil { + return err + } + + clusterUpdate := avs.ClusterUpdate{ + ClusterUpdateProperties: &avs.ClusterUpdateProperties{}, + } + if d.HasChange("cluster_size") { + clusterUpdate.ClusterUpdateProperties.ClusterSize = utils.Int32(int32(d.Get("cluster_size").(int))) + } + + future, err := client.Update(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name, clusterUpdate) + if err != nil { + return fmt.Errorf("updating Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on updating future for Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + return resourceArmAvsClusterRead(d, meta) +} + +func resourceArmAvsClusterDelete(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.ClusterClient + ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsClusterID(d.Id()) + if err != nil { + return err + } + + future, err := client.Delete(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + if err != nil { + return fmt.Errorf("deleting Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on deleting future for Avs Cluster %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + return nil +} diff --git a/azurerm/internal/services/avs/client/client.go b/azurerm/internal/services/avs/client/client.go index ca0362e7231b..07532c5f5e12 100644 --- a/azurerm/internal/services/avs/client/client.go +++ b/azurerm/internal/services/avs/client/client.go @@ -7,13 +7,18 @@ import ( type Client struct { PrivateCloudClient *avs.PrivateCloudsClient + ClusterClient *avs.ClustersClient } func NewClient(o *common.ClientOptions) *Client { privateCloudClient := avs.NewPrivateCloudsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) o.ConfigureClient(&privateCloudClient.Client, o.ResourceManagerAuthorizer) + clusterClient := avs.NewClustersClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&clusterClient.Client, o.ResourceManagerAuthorizer) + return &Client{ PrivateCloudClient: &privateCloudClient, + ClusterClient: &clusterClient, } } diff --git a/azurerm/internal/services/avs/parse/avs_clusters.go b/azurerm/internal/services/avs/parse/avs_clusters.go new file mode 100644 index 000000000000..7aac683ab97e --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_clusters.go @@ -0,0 +1,34 @@ +package parse + +import ( + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) + +type AvsClusterId struct { + ResourceGroup string + PrivateCloudName string + Name string +} + +func AvsClusterID(input string) (*AvsClusterId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsCluster ID %q: %+v", input, err) + } + + avsCluster := AvsClusterId{ + ResourceGroup: id.ResourceGroup, + } + if avsCluster.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if avsCluster.Name, err = id.PopSegment("clusters"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &avsCluster, nil +} diff --git a/azurerm/internal/services/avs/parse/avs_clusters_test.go b/azurerm/internal/services/avs/parse/avs_clusters_test.go new file mode 100644 index 000000000000..eaf40698c48b --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_clusters_test.go @@ -0,0 +1,77 @@ +package parse + +import ( + "testing" +) + +func TestAvsClusterID(t *testing.T) { + testData := []struct { + Name string + Input string + Expected *AvsClusterId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing Cluster Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters", + Expected: nil, + }, + { + Name: "avs Cluster ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters/cluster1", + Expected: &AvsClusterId{ + ResourceGroup: "resourceGroup1", + PrivateCloudName: "privateCloud1", + Name: "cluster1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/Clusters/cluster1", + Expected: nil, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) + + actual, err := AvsClusterID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } + + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + + if actual.PrivateCloudName != v.Expected.PrivateCloudName { + t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) + } + + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/avs/registration.go b/azurerm/internal/services/avs/registration.go index f6d02a09485a..83e2c68b460d 100644 --- a/azurerm/internal/services/avs/registration.go +++ b/azurerm/internal/services/avs/registration.go @@ -27,5 +27,6 @@ func (r Registration) SupportedDataSources() map[string]*schema.Resource { func (r Registration) SupportedResources() map[string]*schema.Resource { return map[string]*schema.Resource{ "azurerm_avs_private_cloud": resourceArmAvsPrivateCloud(), + "azurerm_avs_cluster": resourceArmAvsCluster(), } } diff --git a/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go b/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go new file mode 100644 index 000000000000..c0414fc85924 --- /dev/null +++ b/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go @@ -0,0 +1,191 @@ +package tests + +import ( + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "testing" +) + +func TestAccAzureRMavsCluster_basic(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_cluster", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsClusterDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func TestAccAzureRMavsCluster_requiresImport(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_cluster", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsClusterDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.RequiresImportErrorStep(testAccAzureRMavsCluster_requiresImport), + }, + }) +} + +func TestAccAzureRMavsCluster_update(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_cluster", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsClusterDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsCluster_update(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + { + Config: testAccAzureRMavsCluster_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsClusterExists(data.ResourceName), + ), + }, + data.ImportStep(), + }, + }) +} + +func testCheckAzureRMavsClusterExists(resourceName string) resource.TestCheckFunc { + return func(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.ClusterClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("avs Cluster not found: %s", resourceName) + } + id, err := parse.AvsClusterID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Avs Cluster %q does not exist", id.Name) + } + return fmt.Errorf("bad: Get on Avs.ClusterClient: %+v", err) + } + return nil + } +} + +func testCheckAzureRMavsClusterDestroy(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.ClusterClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + + for _, rs := range s.RootModule().Resources { + if rs.Type != "azurerm_avs_cluster" { + continue + } + id, err := parse.AvsClusterID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Get on Avs.ClusterClient: %+v", err) + } + } + return nil + } + return nil +} + +func testAccAzureRMavsCluster_template(data acceptance.TestData) string { + return fmt.Sprintf(` +provider "azurerm" { + features {} +} + +resource "azurerm_resource_group" "test" { + name = "acctest-avs-%[1]d" + location = "%[2]s" +} + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%[1]d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + sku_name = "av36" + + management_cluster { + cluster_size = 3 + } + network_block = "192.168.48.0/22" +} +`, data.RandomInteger, data.Locations.Primary) +} + +func testAccAzureRMavsCluster_basic(data acceptance.TestData) string { + template := testAccAzureRMavsCluster_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_cluster" "test" { + name = "acctest-ac-%d" + private_cloud_id = azurerm_avs_private_cloud.test.id + cluster_size = 3 + sku_name = "av36t" +} +`, template, data.RandomInteger) +} + +func testAccAzureRMavsCluster_requiresImport(data acceptance.TestData) string { + config := testAccAzureRMavsCluster_basic(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_cluster" "import" { + name = azurerm_avs_cluster.test.name + private_cloud_id = azurerm_avs_cluster.test.private_cloud_id + cluster_size = azurerm_avs_cluster.test.cluster_size + sku_name = azurerm_avs_cluster.test.sku_name +} +`, config) +} + +func testAccAzureRMavsCluster_update(data acceptance.TestData) string { + template := testAccAzureRMavsCluster_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_cluster" "test" { + name = "acctest-ac-%d" + private_cloud_name = azurerm_avs_private_cloud.test.id + cluster_size = 4 + sku_name = "av36t" +} +`, template, data.RandomInteger) +} diff --git a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go index 6ce7bdf9fc66..dfa0c725efad 100644 --- a/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_private_clouds_resource_test.go @@ -227,7 +227,7 @@ func testAccAzureRMavsPrivateCloud_basic(data acceptance.TestData) string { %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-APC-%d" resource_group_name = azurerm_resource_group.test.name location = azurerm_resource_group.test.location sku_name = "av36" @@ -265,7 +265,7 @@ func testAccAzureRMavsPrivateCloud_complete(data acceptance.TestData) string { %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-APC-%d" resource_group_name = azurerm_resource_group.test.name location = azurerm_resource_group.test.location sku_name = "AV36" @@ -290,7 +290,7 @@ func testAccAzureRMavsPrivateCloud_update(data acceptance.TestData) string { %s resource "azurerm_avs_private_cloud" "test" { - name = "acctest-apc-%d" + name = "acctest-APC-%d" resource_group_name = azurerm_resource_group.test.name location = azurerm_resource_group.test.location sku_name = "AV36" From b62e19e31b7156b026ea4af2e8eb8a620c5604ff Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 17 Sep 2020 14:28:48 +0800 Subject: [PATCH 13/23] update --- .../services/avs/avs_clusters_resource.go | 6 +++--- .../avs/tests/avs_clusters_resource_test.go | 17 +++++++++++++++-- 2 files changed, 18 insertions(+), 5 deletions(-) diff --git a/azurerm/internal/services/avs/avs_clusters_resource.go b/azurerm/internal/services/avs/avs_clusters_resource.go index 85cb336680d3..2cc6febacf9a 100644 --- a/azurerm/internal/services/avs/avs_clusters_resource.go +++ b/azurerm/internal/services/avs/avs_clusters_resource.go @@ -24,10 +24,10 @@ func resourceArmAvsCluster() *schema.Resource { Delete: resourceArmAvsClusterDelete, Timeouts: &schema.ResourceTimeout{ - Create: schema.DefaultTimeout(240 * time.Minute), + Create: schema.DefaultTimeout(5 * time.Hour), Read: schema.DefaultTimeout(5 * time.Minute), - Update: schema.DefaultTimeout(240 * time.Minute), - Delete: schema.DefaultTimeout(240 * time.Minute), + Update: schema.DefaultTimeout(5 * time.Hour), + Delete: schema.DefaultTimeout(5 * time.Hour), }, Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { diff --git a/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go b/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go index c0414fc85924..16de736debef 100644 --- a/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go +++ b/azurerm/internal/services/avs/tests/avs_clusters_resource_test.go @@ -9,6 +9,7 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" "testing" + "time" ) func TestAccAzureRMavsCluster_basic(t *testing.T) { @@ -25,6 +26,10 @@ func TestAccAzureRMavsCluster_basic(t *testing.T) { ), }, data.ImportStep(), + { + PreConfig: func() { time.Sleep(17 * time.Minute) }, + Config: testAccAzureRMavsCluster_basic(data), + }, }, }) } @@ -43,6 +48,10 @@ func TestAccAzureRMavsCluster_requiresImport(t *testing.T) { ), }, data.RequiresImportErrorStep(testAccAzureRMavsCluster_requiresImport), + { + PreConfig: func() { time.Sleep(17 * time.Minute) }, + Config: testAccAzureRMavsCluster_requiresImport(data), + }, }, }) } @@ -75,6 +84,10 @@ func TestAccAzureRMavsCluster_update(t *testing.T) { ), }, data.ImportStep(), + { + PreConfig: func() { time.Sleep(17 * time.Minute) }, + Config: testAccAzureRMavsCluster_basic(data), + }, }, }) } @@ -154,7 +167,7 @@ func testAccAzureRMavsCluster_basic(data acceptance.TestData) string { %s resource "azurerm_avs_cluster" "test" { - name = "acctest-ac-%d" + name = "acctest-AC-%d" private_cloud_id = azurerm_avs_private_cloud.test.id cluster_size = 3 sku_name = "av36t" @@ -182,7 +195,7 @@ func testAccAzureRMavsCluster_update(data acceptance.TestData) string { %s resource "azurerm_avs_cluster" "test" { - name = "acctest-ac-%d" + name = "acctest-AC-%d" private_cloud_name = azurerm_avs_private_cloud.test.id cluster_size = 4 sku_name = "av36t" From 2a195a5b0e1a690a2ebf895bc00cf5ee8a5bd0bb Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Fri, 18 Sep 2020 09:55:42 +0800 Subject: [PATCH 14/23] update --- .../internal/services/avs/avs_private_clouds_resource.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index 75ed12f9f477..e8b822bbb45c 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -28,10 +28,10 @@ func resourceArmAvsPrivateCloud() *schema.Resource { Delete: resourceArmAvsPrivateCloudDelete, Timeouts: &schema.ResourceTimeout{ - Create: schema.DefaultTimeout(240 * time.Minute), + Create: schema.DefaultTimeout(5 * time.Hour), Read: schema.DefaultTimeout(5 * time.Minute), - Update: schema.DefaultTimeout(240 * time.Minute), - Delete: schema.DefaultTimeout(240 * time.Minute), + Update: schema.DefaultTimeout(5 * time.Hour), + Delete: schema.DefaultTimeout(5 * time.Hour), }, Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { From 3607df88683236d23c338b14fd943685b5f23914 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Fri, 18 Sep 2020 10:36:45 +0800 Subject: [PATCH 15/23] add auth --- .../avs/avs_authorizations_resource.go | 158 ++++++++++++++++++ .../internal/services/avs/client/client.go | 13 +- .../services/avs/parse/avs_authorizations.go | 34 ++++ .../avs/parse/avs_authorizations_test.go | 77 +++++++++ azurerm/internal/services/avs/registration.go | 1 + .../tests/avs_authorizations_resource_test.go | 145 ++++++++++++++++ 6 files changed, 424 insertions(+), 4 deletions(-) create mode 100644 azurerm/internal/services/avs/avs_authorizations_resource.go create mode 100644 azurerm/internal/services/avs/parse/avs_authorizations.go create mode 100644 azurerm/internal/services/avs/parse/avs_authorizations_test.go create mode 100644 azurerm/internal/services/avs/tests/avs_authorizations_resource_test.go diff --git a/azurerm/internal/services/avs/avs_authorizations_resource.go b/azurerm/internal/services/avs/avs_authorizations_resource.go new file mode 100644 index 000000000000..7ad3486b619b --- /dev/null +++ b/azurerm/internal/services/avs/avs_authorizations_resource.go @@ -0,0 +1,158 @@ +package avs + +import ( + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "log" + "time" +) + +func resourceArmAvsAuthorization() *schema.Resource { + return &schema.Resource{ + Create: resourceArmAvsAuthorizationCreate, + Read: resourceArmAvsAuthorizationRead, + Delete: resourceArmAvsAuthorizationDelete, + + Timeouts: &schema.ResourceTimeout{ + Create: schema.DefaultTimeout(30 * time.Minute), + Read: schema.DefaultTimeout(5 * time.Minute), + Delete: schema.DefaultTimeout(30 * time.Minute), + }, + + Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { + _, err := parse.AvsAuthorizationID(id) + return err + }), + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "private_cloud_id": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "express_route_authorization_id": { + Type: schema.TypeString, + Computed: true, + }, + + "express_route_authorization_key": { + Type: schema.TypeString, + Computed: true, + }, + }, + } +} +func resourceArmAvsAuthorizationCreate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.AuthorizationClient + ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d) + defer cancel() + + name := d.Get("name").(string) + pcId, _ := parse.AvsPrivateCloudID(d.Get("private_cloud_id").(string)) + + if d.IsNewResource() { + existing, err := client.Get(ctx, pcId.ResourceGroup, pcId.Name, name) + if err != nil { + if !utils.ResponseWasNotFound(existing.Response) { + return fmt.Errorf("checking for present of existing Avs Authorization %q (Resource Group %q / privateCloudName %q): %+v", name, pcId.ResourceGroup, pcId.Name, err) + } + } + if existing.ID != nil && *existing.ID != "" { + return tf.ImportAsExistsError("azurerm_avs_authorization", *existing.ID) + } + } + + future, err := client.CreateOrUpdate(ctx, pcId.ResourceGroup, pcId.Name, name, nil) + if err != nil { + return fmt.Errorf("creating/updating Avs Authorization %q (Resource Group %q / privateCloudName %q): %+v", name, pcId.ResourceGroup, pcId.Name, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on creating/updating future for Avs Authorization %q (Resource Group %q / privateCloudName %q): %+v", name, pcId.ResourceGroup, pcId.Name, err) + } + + resp, err := client.Get(ctx, pcId.ResourceGroup, pcId.Name, name) + if err != nil { + return fmt.Errorf("retrieving Avs Authorization %q (Resource Group %q / privateCloudName %q): %+v", name, pcId.ResourceGroup, pcId.Name, err) + } + + if resp.ID == nil || *resp.ID == "" { + return fmt.Errorf("empty or nil ID returned for Avs Authorization %q (Resource Group %q / privateCloudName %q) ID", name, pcId.ResourceGroup, pcId.Name) + } + + d.SetId(*resp.ID) + return resourceArmAvsAuthorizationRead(d, meta) +} + +func resourceArmAvsAuthorizationRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.AuthorizationClient + pcClient := meta.(*clients.Client).Avs.PrivateCloudClient + ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsAuthorizationID(d.Id()) + if err != nil { + return err + } + + resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + if err != nil { + if utils.ResponseWasNotFound(resp.Response) { + log.Printf("[INFO] avs %q does not exist - removing from state", d.Id()) + d.SetId("") + return nil + } + return fmt.Errorf("retrieving Avs Authorization %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + d.Set("name", id.Name) + + pcResp, err := pcClient.Get(ctx, id.ResourceGroup, id.PrivateCloudName) + if err != nil { + return fmt.Errorf("retrieving Avs PrivateCloud %q (Resource Group %q): %+v", id.PrivateCloudName, id.ResourceGroup, err) + } + + if pcResp.ID == nil || *pcResp.ID == "" { + return fmt.Errorf("avs PrivateCloud %q (Resource Group %q) ID is empty or nil", id.PrivateCloudName, id.ResourceGroup) + } + + d.Set("private_cloud_id", pcResp.ID) + if props := resp.ExpressRouteAuthorizationProperties; props != nil { + d.Set("express_route_authorization_id", props.ExpressRouteAuthorizationID) + d.Set("express_route_authorization_key", props.ExpressRouteAuthorizationKey) + } + return nil +} + +func resourceArmAvsAuthorizationDelete(d *schema.ResourceData, meta interface{}) error { + client := meta.(*clients.Client).Avs.AuthorizationClient + ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) + defer cancel() + + id, err := parse.AvsAuthorizationID(d.Id()) + if err != nil { + return err + } + + future, err := client.Delete(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + if err != nil { + return fmt.Errorf("deleting Avs Authorization %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + + if err := future.WaitForCompletionRef(ctx, client.Client); err != nil { + return fmt.Errorf("waiting on deleting future for Avs Authorization %q (Resource Group %q / privateCloudName %q): %+v", id.Name, id.ResourceGroup, id.PrivateCloudName, err) + } + return nil +} diff --git a/azurerm/internal/services/avs/client/client.go b/azurerm/internal/services/avs/client/client.go index 07532c5f5e12..e5643228adaa 100644 --- a/azurerm/internal/services/avs/client/client.go +++ b/azurerm/internal/services/avs/client/client.go @@ -6,8 +6,9 @@ import ( ) type Client struct { - PrivateCloudClient *avs.PrivateCloudsClient - ClusterClient *avs.ClustersClient + PrivateCloudClient *avs.PrivateCloudsClient + ClusterClient *avs.ClustersClient + AuthorizationClient *avs.AuthorizationsClient } func NewClient(o *common.ClientOptions) *Client { @@ -17,8 +18,12 @@ func NewClient(o *common.ClientOptions) *Client { clusterClient := avs.NewClustersClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) o.ConfigureClient(&clusterClient.Client, o.ResourceManagerAuthorizer) + authorizationClient := avs.NewAuthorizationsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId) + o.ConfigureClient(&authorizationClient.Client, o.ResourceManagerAuthorizer) + return &Client{ - PrivateCloudClient: &privateCloudClient, - ClusterClient: &clusterClient, + PrivateCloudClient: &privateCloudClient, + ClusterClient: &clusterClient, + AuthorizationClient: &authorizationClient, } } diff --git a/azurerm/internal/services/avs/parse/avs_authorizations.go b/azurerm/internal/services/avs/parse/avs_authorizations.go new file mode 100644 index 000000000000..f8f051218c28 --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_authorizations.go @@ -0,0 +1,34 @@ +package parse + +import ( + "fmt" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) + +type AvsAuthorizationId struct { + ResourceGroup string + PrivateCloudName string + Name string +} + +func AvsAuthorizationID(input string) (*AvsAuthorizationId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, fmt.Errorf("parsing avsAuthorization ID %q: %+v", input, err) + } + + avsAuthorization := AvsAuthorizationId{ + ResourceGroup: id.ResourceGroup, + } + if avsAuthorization.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if avsAuthorization.Name, err = id.PopSegment("authorizations"); err != nil { + return nil, err + } + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &avsAuthorization, nil +} diff --git a/azurerm/internal/services/avs/parse/avs_authorizations_test.go b/azurerm/internal/services/avs/parse/avs_authorizations_test.go new file mode 100644 index 000000000000..4f81b0b5c96d --- /dev/null +++ b/azurerm/internal/services/avs/parse/avs_authorizations_test.go @@ -0,0 +1,77 @@ +package parse + +import ( + "testing" +) + +func TestAvsAuthorizationID(t *testing.T) { + testData := []struct { + Name string + Input string + Expected *AvsAuthorizationId + }{ + { + Name: "Empty", + Input: "", + Expected: nil, + }, + { + Name: "No Resource Groups Segment", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000", + Expected: nil, + }, + { + Name: "No Resource Groups Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/", + Expected: nil, + }, + { + Name: "Resource Group ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/foo/", + Expected: nil, + }, + { + Name: "Missing Authorization Value", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations", + Expected: nil, + }, + { + Name: "avs Authorization ID", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1", + Expected: &AvsAuthorizationId{ + ResourceGroup: "resourceGroup1", + PrivateCloudName: "privateCloud1", + Name: "authorization1", + }, + }, + { + Name: "Wrong Casing", + Input: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/Authorizations/authorization1", + Expected: nil, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q..", v.Name) + + actual, err := AvsAuthorizationID(v.Input) + if err != nil { + if v.Expected == nil { + continue + } + t.Fatalf("Expected a value but got an error: %s", err) + } + + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + + if actual.PrivateCloudName != v.Expected.PrivateCloudName { + t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) + } + + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/avs/registration.go b/azurerm/internal/services/avs/registration.go index 83e2c68b460d..a53ef286d35b 100644 --- a/azurerm/internal/services/avs/registration.go +++ b/azurerm/internal/services/avs/registration.go @@ -28,5 +28,6 @@ func (r Registration) SupportedResources() map[string]*schema.Resource { return map[string]*schema.Resource{ "azurerm_avs_private_cloud": resourceArmAvsPrivateCloud(), "azurerm_avs_cluster": resourceArmAvsCluster(), + "azurerm_avs_authorization": resourceArmAvsAuthorization(), } } diff --git a/azurerm/internal/services/avs/tests/avs_authorizations_resource_test.go b/azurerm/internal/services/avs/tests/avs_authorizations_resource_test.go new file mode 100644 index 000000000000..b11cf140e3ea --- /dev/null +++ b/azurerm/internal/services/avs/tests/avs_authorizations_resource_test.go @@ -0,0 +1,145 @@ +package tests + +import ( + "fmt" + "github.com/hashicorp/terraform-plugin-sdk/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/terraform" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/avs/parse" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" + "testing" +) + +func TestAccAzureRMavsAuthorization_basic(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_authorization", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsAuthorizationDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsAuthorization_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsAuthorizationExists(data.ResourceName), + resource.TestCheckResourceAttrSet(data.ResourceName, "express_route_authorization_id"), + resource.TestCheckResourceAttrSet(data.ResourceName, "express_route_authorization_key"), + ), + }, + data.ImportStep(), + }, + }) +} + +func TestAccAzureRMavsAuthorization_requiresImport(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_avs_authorization", "test") + resource.ParallelTest(t, resource.TestCase{ + PreCheck: func() { acceptance.PreCheck(t) }, + Providers: acceptance.SupportedProviders, + CheckDestroy: testCheckAzureRMavsAuthorizationDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAzureRMavsAuthorization_basic(data), + Check: resource.ComposeTestCheckFunc( + testCheckAzureRMavsAuthorizationExists(data.ResourceName), + ), + }, + data.RequiresImportErrorStep(testAccAzureRMavsAuthorization_requiresImport), + }, + }) +} + +func testCheckAzureRMavsAuthorizationExists(resourceName string) resource.TestCheckFunc { + return func(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.AuthorizationClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("avs Authorization not found: %s", resourceName) + } + id, err := parse.AvsAuthorizationID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Avs Authorization %q does not exist", id.Name) + } + return fmt.Errorf("bad: Get on Avs.AuthorizationClient: %+v", err) + } + return nil + } +} + +func testCheckAzureRMavsAuthorizationDestroy(s *terraform.State) error { + client := acceptance.AzureProvider.Meta().(*clients.Client).Avs.AuthorizationClient + ctx := acceptance.AzureProvider.Meta().(*clients.Client).StopContext + + for _, rs := range s.RootModule().Resources { + if rs.Type != "azurerm_avs_authorization" { + continue + } + id, err := parse.AvsAuthorizationID(rs.Primary.ID) + if err != nil { + return err + } + if resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name); err != nil { + if !utils.ResponseWasNotFound(resp.Response) { + return fmt.Errorf("bad: Get on Avs.AuthorizationClient: %+v", err) + } + } + return nil + } + return nil +} + +func testAccAzureRMavsAuthorization_template(data acceptance.TestData) string { + return fmt.Sprintf(` +provider "azurerm" { + features {} +} + +resource "azurerm_resource_group" "test" { + name = "acctest-avs-%d" + location = "%s" +} + +resource "azurerm_avs_private_cloud" "test" { + name = "acctest-apc-%d" + resource_group_name = azurerm_resource_group.test.name + location = azurerm_resource_group.test.location + network_block = "192.168.48.0/22" + sku { + name = "av36" + } + + management_cluster { + cluster_size = 3 + } +} +`, data.RandomInteger, data.Locations.Primary, data.RandomInteger) +} + +func testAccAzureRMavsAuthorization_basic(data acceptance.TestData) string { + template := testAccAzureRMavsAuthorization_template(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_authorization" "test" { + name = "acctest-AA-%d" + private_cloud_id = azurerm_avs_private_cloud.test.id +} +`, template, data.RandomInteger) +} + +func testAccAzureRMavsAuthorization_requiresImport(data acceptance.TestData) string { + config := testAccAzureRMavsAuthorization_basic(data) + return fmt.Sprintf(` +%s + +resource "azurerm_avs_authorization" "import" { + name = azurerm_avs_authorization.test.name + private_cloud_id = azurerm_avs_private_cloud.test.id +} +`, config) +} From 1c2b6382239a3dc7827f34c7e417fcf9de4e3801 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Mon, 21 Sep 2020 16:53:31 +0800 Subject: [PATCH 16/23] update --- azurerm/internal/services/avs/avs_private_clouds_resource.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/azurerm/internal/services/avs/avs_private_clouds_resource.go b/azurerm/internal/services/avs/avs_private_clouds_resource.go index e8b822bbb45c..0ccd5c232528 100644 --- a/azurerm/internal/services/avs/avs_private_clouds_resource.go +++ b/azurerm/internal/services/avs/avs_private_clouds_resource.go @@ -315,7 +315,7 @@ func resourceArmAvsPrivateCloudUpdate(d *schema.ResourceData, meta interface{}) } if d.HasChange("internet_connected") { internet := avs.Disabled - if d.Get("internet").(bool) { + if d.Get("internet_connected").(bool) { internet = avs.Enabled } privateCloudUpdate.PrivateCloudUpdateProperties.Internet = internet From 648685f97765be88c4cde5f77e83ed57098a81f7 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 20 May 2021 14:46:19 +0800 Subject: [PATCH 17/23] update --- .../services/vmware/parse/authorization.go | 75 ++++++++++ .../vmware/parse/authorization_test.go | 128 ++++++++++++++++++ .../vmware/validate/authorization_id.go | 23 ++++ .../vmware/validate/authorization_id_test.go | 88 ++++++++++++ 4 files changed, 314 insertions(+) create mode 100644 azurerm/internal/services/vmware/parse/authorization.go create mode 100644 azurerm/internal/services/vmware/parse/authorization_test.go create mode 100644 azurerm/internal/services/vmware/validate/authorization_id.go create mode 100644 azurerm/internal/services/vmware/validate/authorization_id_test.go diff --git a/azurerm/internal/services/vmware/parse/authorization.go b/azurerm/internal/services/vmware/parse/authorization.go new file mode 100644 index 000000000000..468243638836 --- /dev/null +++ b/azurerm/internal/services/vmware/parse/authorization.go @@ -0,0 +1,75 @@ +package parse + +// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten + +import ( + "fmt" + "strings" + + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" +) + +type AuthorizationId struct { + SubscriptionId string + ResourceGroup string + PrivateCloudName string + Name string +} + +func NewAuthorizationID(subscriptionId, resourceGroup, privateCloudName, name string) AuthorizationId { + return AuthorizationId{ + SubscriptionId: subscriptionId, + ResourceGroup: resourceGroup, + PrivateCloudName: privateCloudName, + Name: name, + } +} + +func (id AuthorizationId) String() string { + segments := []string{ + fmt.Sprintf("Name %q", id.Name), + fmt.Sprintf("Private Cloud Name %q", id.PrivateCloudName), + fmt.Sprintf("Resource Group %q", id.ResourceGroup), + } + segmentsStr := strings.Join(segments, " / ") + return fmt.Sprintf("%s: (%s)", "Authorization", segmentsStr) +} + +func (id AuthorizationId) ID() string { + fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.AVS/privateClouds/%s/authorizations/%s" + return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.PrivateCloudName, id.Name) +} + +// AuthorizationID parses a Authorization ID into an AuthorizationId struct +func AuthorizationID(input string) (*AuthorizationId, error) { + id, err := azure.ParseAzureResourceID(input) + if err != nil { + return nil, err + } + + resourceId := AuthorizationId{ + SubscriptionId: id.SubscriptionID, + ResourceGroup: id.ResourceGroup, + } + + if resourceId.SubscriptionId == "" { + return nil, fmt.Errorf("ID was missing the 'subscriptions' element") + } + + if resourceId.ResourceGroup == "" { + return nil, fmt.Errorf("ID was missing the 'resourceGroups' element") + } + + if resourceId.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { + return nil, err + } + if resourceId.Name, err = id.PopSegment("authorizations"); err != nil { + return nil, err + } + + if err := id.ValidateNoEmptySegments(input); err != nil { + return nil, err + } + + return &resourceId, nil +} diff --git a/azurerm/internal/services/vmware/parse/authorization_test.go b/azurerm/internal/services/vmware/parse/authorization_test.go new file mode 100644 index 000000000000..1d7a54cb5eed --- /dev/null +++ b/azurerm/internal/services/vmware/parse/authorization_test.go @@ -0,0 +1,128 @@ +package parse + +// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten + +import ( + "testing" + + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/resourceid" +) + +var _ resourceid.Formatter = AuthorizationId{} + +func TestAuthorizationIDFormatter(t *testing.T) { + actual := NewAuthorizationID("12345678-1234-9876-4563-123456789012", "group1", "privateCloud1", "authorization1").ID() + expected := "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1" + if actual != expected { + t.Fatalf("Expected %q but got %q", expected, actual) + } +} + +func TestAuthorizationID(t *testing.T) { + testData := []struct { + Input string + Error bool + Expected *AuthorizationId + }{ + + { + // empty + Input: "", + Error: true, + }, + + { + // missing SubscriptionId + Input: "/", + Error: true, + }, + + { + // missing value for SubscriptionId + Input: "/subscriptions/", + Error: true, + }, + + { + // missing ResourceGroup + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/", + Error: true, + }, + + { + // missing value for ResourceGroup + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/", + Error: true, + }, + + { + // missing PrivateCloudName + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/", + Error: true, + }, + + { + // missing value for PrivateCloudName + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/", + Error: true, + }, + + { + // missing Name + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/", + Error: true, + }, + + { + // missing value for Name + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/", + Error: true, + }, + + { + // valid + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1", + Expected: &AuthorizationId{ + SubscriptionId: "12345678-1234-9876-4563-123456789012", + ResourceGroup: "group1", + PrivateCloudName: "privateCloud1", + Name: "authorization1", + }, + }, + + { + // upper-cased + Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/GROUP1/PROVIDERS/MICROSOFT.AVS/PRIVATECLOUDS/PRIVATECLOUD1/AUTHORIZATIONS/AUTHORIZATION1", + Error: true, + }, + } + + for _, v := range testData { + t.Logf("[DEBUG] Testing %q", v.Input) + + actual, err := AuthorizationID(v.Input) + if err != nil { + if v.Error { + continue + } + + t.Fatalf("Expect a value but got an error: %s", err) + } + if v.Error { + t.Fatal("Expect an error but didn't get one") + } + + if actual.SubscriptionId != v.Expected.SubscriptionId { + t.Fatalf("Expected %q but got %q for SubscriptionId", v.Expected.SubscriptionId, actual.SubscriptionId) + } + if actual.ResourceGroup != v.Expected.ResourceGroup { + t.Fatalf("Expected %q but got %q for ResourceGroup", v.Expected.ResourceGroup, actual.ResourceGroup) + } + if actual.PrivateCloudName != v.Expected.PrivateCloudName { + t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) + } + if actual.Name != v.Expected.Name { + t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + } + } +} diff --git a/azurerm/internal/services/vmware/validate/authorization_id.go b/azurerm/internal/services/vmware/validate/authorization_id.go new file mode 100644 index 000000000000..8ed9489eed87 --- /dev/null +++ b/azurerm/internal/services/vmware/validate/authorization_id.go @@ -0,0 +1,23 @@ +package validate + +// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten + +import ( + "fmt" + + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/vmware/parse" +) + +func AuthorizationID(input interface{}, key string) (warnings []string, errors []error) { + v, ok := input.(string) + if !ok { + errors = append(errors, fmt.Errorf("expected %q to be a string", key)) + return + } + + if _, err := parse.AuthorizationID(v); err != nil { + errors = append(errors, err) + } + + return +} diff --git a/azurerm/internal/services/vmware/validate/authorization_id_test.go b/azurerm/internal/services/vmware/validate/authorization_id_test.go new file mode 100644 index 000000000000..4e76d6c789ef --- /dev/null +++ b/azurerm/internal/services/vmware/validate/authorization_id_test.go @@ -0,0 +1,88 @@ +package validate + +// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten + +import "testing" + +func TestAuthorizationID(t *testing.T) { + cases := []struct { + Input string + Valid bool + }{ + + { + // empty + Input: "", + Valid: false, + }, + + { + // missing SubscriptionId + Input: "/", + Valid: false, + }, + + { + // missing value for SubscriptionId + Input: "/subscriptions/", + Valid: false, + }, + + { + // missing ResourceGroup + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/", + Valid: false, + }, + + { + // missing value for ResourceGroup + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/", + Valid: false, + }, + + { + // missing PrivateCloudName + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/", + Valid: false, + }, + + { + // missing value for PrivateCloudName + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/", + Valid: false, + }, + + { + // missing Name + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/", + Valid: false, + }, + + { + // missing value for Name + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/", + Valid: false, + }, + + { + // valid + Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1", + Valid: true, + }, + + { + // upper-cased + Input: "/SUBSCRIPTIONS/12345678-1234-9876-4563-123456789012/RESOURCEGROUPS/GROUP1/PROVIDERS/MICROSOFT.AVS/PRIVATECLOUDS/PRIVATECLOUD1/AUTHORIZATIONS/AUTHORIZATION1", + Valid: false, + }, + } + for _, tc := range cases { + t.Logf("[DEBUG] Testing Value %s", tc.Input) + _, errors := AuthorizationID(tc.Input, "test") + valid := len(errors) == 0 + + if tc.Valid != valid { + t.Fatalf("Expected %t but got %t", tc.Valid, valid) + } + } +} From 44e7f1a3895e4bf00853bfde1998aaa9da9c2d07 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 20 May 2021 14:49:59 +0800 Subject: [PATCH 18/23] update --- .../vmware_authorization_resource_test.go | 4 +- .../docs/d/avs_private_cloud.html.markdown | 96 ---------- .../docs/r/avs_private_cloud.html.markdown | 174 ------------------ 3 files changed, 2 insertions(+), 272 deletions(-) delete mode 100644 website/docs/d/avs_private_cloud.html.markdown delete mode 100644 website/docs/r/avs_private_cloud.html.markdown diff --git a/azurerm/internal/services/vmware/vmware_authorization_resource_test.go b/azurerm/internal/services/vmware/vmware_authorization_resource_test.go index 5804fccf4891..b3f9f0d89172 100644 --- a/azurerm/internal/services/vmware/vmware_authorization_resource_test.go +++ b/azurerm/internal/services/vmware/vmware_authorization_resource_test.go @@ -69,7 +69,7 @@ func (r VmwareAuthorizationResource) basic(data acceptance.TestData) string { resource "azurerm_vmware_authorization" "test" { name = "acctest-VmwareAuthorization-%d" - private_cloud_id = azurerm_avs_private_cloud.test.id + private_cloud_id = azurerm_vmware_private_cloud.test.id } `, VmwarePrivateCloudResource{}.basic(data), data.RandomInteger) } @@ -80,7 +80,7 @@ func (r VmwareAuthorizationResource) requiresImport(data acceptance.TestData) st resource "azurerm_vmware_authorization" "import" { name = azurerm_vmware_authorization.test.name - private_cloud_id = azurerm_avs_private_cloud.test.id + private_cloud_id = azurerm_vmware_private_cloud.test.id } `, r.basic(data)) } diff --git a/website/docs/d/avs_private_cloud.html.markdown b/website/docs/d/avs_private_cloud.html.markdown deleted file mode 100644 index e6c14fa584f5..000000000000 --- a/website/docs/d/avs_private_cloud.html.markdown +++ /dev/null @@ -1,96 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: Data Source: azurerm_avs_private_cloud" -description: |- - Gets information about an existing Azure Vmware Solution Private Cloud. ---- - -# Data Source: azurerm_avs_private_cloud - -Use this data source to access information about an existing Azure Vmware Solution Private Cloud. - -## Example Usage - -```hcl -data "azurerm_avs_private_cloud" "example" { - name = "existing-avs-private-cloud" - resource_group_name = "existing-resgroup" -} - -output "id" { - value = data.azurerm_avs_private_cloud.example.id -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name of this Azure Vmware Solution Private Cloud. - -* `resource_group_name` - (Required) The name of the Resource Group where the Azure Vmware Solution Private Cloud exists. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the Azure Vmware Solution Private Cloud. - -* `location` - The Azure Region where the Azure Vmware Solution Private Cloud exists. - -* `circuit` - A `circuit` block as defined below. - -* `internet_connected` - Is connected to the internet? - -* `management_cluster` - A `management_cluster` block as defined below. - -* `network_block` - The block of addresses which should be unique across virtual network in your subscription as well as on-premise. - -* `hcx_cloud_manager_endpoint` - The endpoint for the HCX Cloud Manager. - -* `nsxt_manager_endpoint` - The endpoint for the NSX-T Data Center manager. - -* `vcsa_endpoint` - The endpoint for Virtual Center Server Appliance. - -* `sku_name` - The name of the SKU. - -* `nsxt_certificate_thumbprint` - The thumbprint of the NSX-T Manager SSL certificate. - -* `vcenter_certificate_thumbprint` - The thumbprint of the vCenter Server SSL certificate. - -* `management_network` - The network used to access vCenter Server and NSX-T Manager. - -* `provisioning_network` - The network which isused for virtual machine cold migration, cloning, and snapshot migration. - -* `vmotion_network` - The network which is used for live migration of virtual machines. - -* `tags` - A mapping of tags assigned to the Azure Vmware Solution Private Cloud. - ---- - -A `circuit` block exports the following: - -* `express_route_id` - The ID of the ExpressRoute Circuit. - -* `express_route_private_peering_id` - The ID of the ExpressRoute Circuit private peering. - -* `primary_subnet` - The CIDR of primary subnet. - -* `secondary_subnet` - The CIDR of secondary subnet. - ---- - -A `management_cluster` block exports the following: - -* `cluster_id` - The ID of the cluster. - -* `cluster_size` - The size of the cluster. - -* `hosts` - The set of the hosts in the cluster. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `read` - (Defaults to 5 minutes) Used when retrieving the Azure Vmware Solution Private Cloud. diff --git a/website/docs/r/avs_private_cloud.html.markdown b/website/docs/r/avs_private_cloud.html.markdown deleted file mode 100644 index 559f08874d33..000000000000 --- a/website/docs/r/avs_private_cloud.html.markdown +++ /dev/null @@ -1,174 +0,0 @@ ---- -subcategory: "Avs" -layout: "azurerm" -page_title: "Azure Resource Manager: azurerm_avs_private_cloud" -description: |- - Manages a Azure Vmware Solution Private Cloud. ---- - -# azurerm_avs_private_cloud - -Manages a Azure Vmware Solution Private Cloud. - -## Example Usage - -```hcl -provider "azurerm" { - features {} -} - -resource "azurerm_resource_group" "example" { - name = "example-resources" - location = "West Europe" -} - -resource "azurerm_avs_private_cloud" "example" { - name = "example-avs-private-cloud" - resource_group_name = azurerm_resource_group.example.name - location = azurerm_resource_group.example.location - sku_name = "AV36" - - management_cluster { - cluster_size = 3 - } - - network_block = "192.168.48.0/22" - - identity_source { - name = "exampleName" - alias = "exampleAlias" - base_group_dn = "exampleGp" - base_user_dn = "exampleUser" - domain = "exampleDomain" - password = "PassWord1234!" - primary_server_url = "http://example.com" - secondary_server_url = "http://example2.com" - ssl_enabled = false - username = "exampleUser" - } - - internet_connected = false - nsxt_password = "QazWsx13$Edc" - vcenter_password = "QazWsx13$Edc" - tags = { - foo = "bar" - } -} -``` - -## Arguments Reference - -The following arguments are supported: - -* `name` - (Required) The name which should be used for this Azure Vmware Solution Private Cloud. Changing this forces a new Azure Vmware Solution Private Cloud to be created. - -* `resource_group_name` - (Required) The name of the Resource Group where the Azure Vmware Solution Private Cloud should exist. Changing this forces a new Azure Vmware Solution Private Cloud to be created. - -* `location` - (Required) The Azure Region where the Azure Vmware Solution Private Cloud should exist. Changing this forces a new Azure Vmware Solution Private Cloud to be created. - -* `management_cluster` - (Required) A `management_cluster` block as defined below. - -* `network_block` - (Required) The block of addresses which should be unique across virtual network in your subscription as well as on-premise. Changing this forces a new Azure Vmware Solution Private Cloud to be created. - -* `sku_name` - (Required) The name of the SKU. Changing this forces a new Azure Vmware Solution Private Cloud to be created. Possible values are "av20", "av36" and "av36t". - -* `identity_source` - (Optional) One or more `identity_source` blocks as defined below. - -* `internet_connected` - (Optional) Is connected to the internet? - -* `nsxt_password` - (Optional) The password of the NSX-T Manager. Changing this forces a new Azure Vmware Solution Private Cloud to be created. - -* `vcenter_password` - (Optional) The password of the vCenter admin. Changing this forces a new Azure Vmware Solution Private Cloud to be created. - -* `tags` - (Optional) A mapping of tags which should be assigned to the Azure Vmware Solution Private Cloud. - ---- - -A `identity_source` block supports the following: - -* `name` - (Required) The name of the identity source - -* `alias` - (Required) The domain's NetBIOS name. - -* `base_group_dn` - (Required) The base distinguished name for groups. - -* `base_user_dn` - (Required) The base distinguished name for users. - -* `domain` - (Required) The domain's dns name. - -* `primary_server_url` - (Required) The primary server URL. - -* `secondary_server_url` - (Optional) The secondary server URL. - -* `ssl_enabled` - (Required) Should we protect LDAP communication using SSL certificate (LDAPS)? - -* `username` - (Required) The ID of an Active Directory user with a minimum of read-only access to Base DN for users and group. - -* `password` - (Required) The password of the Active Directory user with a minimum of read-only access to Base DN for users and groups. - ---- - -A `management_cluster` block supports the following: - -* `cluster_size` - (Required) The size of the cluster. - -## Attributes Reference - -In addition to the Arguments listed above - the following Attributes are exported: - -* `id` - The ID of the Azure Vmware Solution Private Cloud. - -* `circuit` - A `circuit` block as defined below. - -* `hcx_cloud_manager_endpoint` - The endpoint for the HCX Cloud Manager. - -* `nsxt_manager_endpoint` - The endpoint for the NSX-T Data Center manager. - -* `vcsa_endpoint` - The endpoint for Virtual Center Server Appliance. - -* `nsxt_certificate_thumbprint` - The thumbprint of the NSX-T Manager SSL certificate. - -* `vcenter_certificate_thumbprint` - The thumbprint of the vCenter Server SSL certificate. - -* `management_network` - The network used to access vCenter Server and NSX-T Manager. - -* `provisioning_network` - The network which isused for virtual machine cold migration, cloning, and snapshot migration. - -* `vmotion_network` - The network which is used for live migration of virtual machines. - ---- - -A `circuit` block exports the following: - -* `express_route_id` - The ID of the ExpressRoute Circuit. - -* `express_route_private_peering_id` - The ID of the ExpressRoute Circuit private peering. - -* `primary_subnet` - The CIDR of primary subnet. - -* `secondary_subnet` - The CIDR of secondary subnet. - ---- - -A `management_cluster` block exports the following: - -* `cluster_id` - The ID of the cluster. - -* `hosts` - The set of the hosts in the cluster. - -## Timeouts - -The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: - -* `create` - (Defaults to 4 hours) Used when creating the Azure Vmware Solution Private Cloud. -* `read` - (Defaults to 5 minutes) Used when retrieving the Azure Vmware Solution Private Cloud. -* `update` - (Defaults to 4 hours) Used when updating the Azure Vmware Solution Private Cloud. -* `delete` - (Defaults to 4 hours) Used when deleting the Azure Vmware Solution Private Cloud. - -## Import - -Azure Vmware Solution Private Clouds can be imported using the `resource id`, e.g. - -```shell -terraform import azurerm_avs_private_cloud.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.AVS/PrivateClouds/privateCloud1 -``` From 66c8fc44b03ef243d8c97711deeace43e43e753a Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 20 May 2021 14:55:25 +0800 Subject: [PATCH 19/23] update --- .../vmware/vmware_authorization_resource.go | 5 +- .../docs/r/vmware_authorization.html.markdown | 80 +++++++++++++++++++ 2 files changed, 83 insertions(+), 2 deletions(-) create mode 100644 website/docs/r/vmware_authorization.html.markdown diff --git a/azurerm/internal/services/vmware/vmware_authorization_resource.go b/azurerm/internal/services/vmware/vmware_authorization_resource.go index 5c240782b759..6cf2d8acd5d6 100644 --- a/azurerm/internal/services/vmware/vmware_authorization_resource.go +++ b/azurerm/internal/services/vmware/vmware_authorization_resource.go @@ -55,8 +55,9 @@ func resourceVmwareAuthorization() *schema.Resource { }, "express_route_authorization_key": { - Type: schema.TypeString, - Computed: true, + Type: schema.TypeString, + Computed: true, + Sensitive: true, }, }, } diff --git a/website/docs/r/vmware_authorization.html.markdown b/website/docs/r/vmware_authorization.html.markdown new file mode 100644 index 000000000000..f9ac6a62ba05 --- /dev/null +++ b/website/docs/r/vmware_authorization.html.markdown @@ -0,0 +1,80 @@ +--- +subcategory: "VMware (AVS)" +layout: "azurerm" +page_title: "Azure Resource Manager: azurerm_vmware_authorization" +description: |- + Manages a Vmware Authorization. +--- + +# azurerm_vmware_authorization + +Manages a Vmware Authorization. + +## Example Usage + +```hcl +provider "azurerm" { + features {} + disable_correlation_request_id = true +} + +resource "azurerm_resource_group" "example" { + name = "example-resources" + location = "West Europe" +} + +resource "azurerm_vmware_private_cloud" "example" { + name = "example-vmware-private-cloud" + resource_group_name = azurerm_resource_group.example.name + location = azurerm_resource_group.example.location + sku_name = "av36" + + management_cluster { + size = 3 + } + + network_subnet_cidr = "192.168.48.0/22" + internet_connection_enabled = false + nsxt_password = "QazWsx13$Edc" + vcenter_password = "WsxEdc23$Rfv" +} + +resource "azurerm_vmware_authorization" "example" { + name = "example-authorization" + private_cloud_id = azurerm_vmware_private_cloud.example.id +} +``` + +## Arguments Reference + +The following arguments are supported: + +* `name` - (Required) The name which should be used for this Vmware Authorization. Changing this forces a new Vmware Authorization to be created. + +* `private_cloud_id` - (Required) The ID of the Vmware Private Cloud in which to create this Vmware Authorization. Changing this forces a new Vmware Authorization to be created. + +## Attributes Reference + +In addition to the Arguments listed above - the following Attributes are exported: + +* `id` - The ID of the Vmware Authorization. + +* `express_route_authorization_id` - The ID of the Express Route Circuit Authorization. + +* `express_route_authorization_key` - The key of the Express Route Circuit Authorization. + +## Timeouts + +The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/docs/configuration/resources.html#timeouts) for certain actions: + +* `create` - (Defaults to 30 minutes) Used when creating the Vmware Authorization. +* `read` - (Defaults to 5 minutes) Used when retrieving the Vmware Authorization. +* `delete` - (Defaults to 30 minutes) Used when deleting the Vmware Authorization. + +## Import + +Vmware Authorizations can be imported using the `resource id`, e.g. + +```shell +terraform import azurerm_vmware_authorization.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1 +``` \ No newline at end of file From 95e94c3a5f4e22de59f80d0029377d41732c7cd8 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Fri, 21 May 2021 09:15:23 +0800 Subject: [PATCH 20/23] update --- .../vmware/vmware_authorization_resource.go | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/azurerm/internal/services/vmware/vmware_authorization_resource.go b/azurerm/internal/services/vmware/vmware_authorization_resource.go index 6cf2d8acd5d6..3410f074b71e 100644 --- a/azurerm/internal/services/vmware/vmware_authorization_resource.go +++ b/azurerm/internal/services/vmware/vmware_authorization_resource.go @@ -65,7 +65,7 @@ func resourceVmwareAuthorization() *schema.Resource { func resourceVmwareAuthorizationCreate(d *schema.ResourceData, meta interface{}) error { subscriptionId := meta.(*clients.Client).Account.SubscriptionId client := meta.(*clients.Client).Vmware.AuthorizationClient - ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d) + ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) defer cancel() name := d.Get("name").(string) @@ -76,17 +76,15 @@ func resourceVmwareAuthorizationCreate(d *schema.ResourceData, meta interface{}) id := parse.NewAuthorizationID(subscriptionId, privateCloudId.ResourceGroup, privateCloudId.Name, name) - if d.IsNewResource() { - existing, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) - if err != nil { - if !utils.ResponseWasNotFound(existing.Response) { - return fmt.Errorf("checking for present of existing %q : %+v", id.ID(), err) - } - } + existing, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + if err != nil { if !utils.ResponseWasNotFound(existing.Response) { - return tf.ImportAsExistsError("azurerm_vmware_authorization", id.ID()) + return fmt.Errorf("checking for present of existing %q : %+v", id.ID(), err) } } + if !utils.ResponseWasNotFound(existing.Response) { + return tf.ImportAsExistsError("azurerm_vmware_authorization", id.ID()) + } props := avs.ExpressRouteAuthorization{} From 7f583cb0cc56feed3c6acc683b2d47d08e3e138a Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Mon, 24 May 2021 15:20:56 +0800 Subject: [PATCH 21/23] update --- ...tion.go => express_route_authorization.go} | 40 +-- ...go => express_route_authorization_test.go} | 30 +- .../internal/services/vmware/registration.go | 6 +- .../internal/services/vmware/resourceids.go | 2 +- ...d.go => express_route_authorization_id.go} | 4 +- ...=> express_route_authorization_id_test.go} | 8 +- ...e_express_route_authorization_resource.go} | 34 +- ...ress_route_authorization_resource_test.go} | 30 +- .../2020-08-04/blob/accounts/README.md | 57 ++++ .../2020-08-04/blob/accounts/client.go | 25 ++ .../blob/accounts/get_service_properties.go | 84 +++++ .../2020-08-04/blob/accounts/models.go | 80 +++++ .../blob/accounts/set_service_properties.go | 77 +++++ .../2020-08-04/blob/accounts/version.go | 14 + .../storage/2020-08-04/blob/blobs/README.md | 46 +++ .../storage/2020-08-04/blob/blobs/api.go | 45 +++ .../2020-08-04/blob/blobs/append_block.go | 180 ++++++++++ .../storage/2020-08-04/blob/blobs/client.go | 25 ++ .../storage/2020-08-04/blob/blobs/copy.go | 235 +++++++++++++ .../2020-08-04/blob/blobs/copy_abort.go | 110 +++++++ .../2020-08-04/blob/blobs/copy_and_wait.go | 41 +++ .../storage/2020-08-04/blob/blobs/delete.go | 105 ++++++ .../2020-08-04/blob/blobs/delete_snapshot.go | 108 ++++++ .../2020-08-04/blob/blobs/delete_snapshots.go | 99 ++++++ .../storage/2020-08-04/blob/blobs/get.go | 116 +++++++ .../2020-08-04/blob/blobs/get_block_list.go | 140 ++++++++ .../2020-08-04/blob/blobs/get_page_ranges.go | 152 +++++++++ .../blob/blobs/incremental_copy_blob.go | 120 +++++++ .../2020-08-04/blob/blobs/lease_acquire.go | 135 ++++++++ .../2020-08-04/blob/blobs/lease_break.go | 124 +++++++ .../2020-08-04/blob/blobs/lease_change.go | 117 +++++++ .../2020-08-04/blob/blobs/lease_release.go | 98 ++++++ .../2020-08-04/blob/blobs/lease_renew.go | 97 ++++++ .../2020-08-04/blob/blobs/metadata_set.go | 113 +++++++ .../storage/2020-08-04/blob/blobs/models.go | 82 +++++ .../2020-08-04/blob/blobs/properties_get.go | 310 ++++++++++++++++++ .../2020-08-04/blob/blobs/properties_set.go | 156 +++++++++ .../2020-08-04/blob/blobs/put_append_blob.go | 134 ++++++++ .../2020-08-04/blob/blobs/put_block.go | 126 +++++++ .../2020-08-04/blob/blobs/put_block_blob.go | 144 ++++++++ .../blob/blobs/put_block_blob_file.go | 34 ++ .../2020-08-04/blob/blobs/put_block_list.go | 157 +++++++++ .../2020-08-04/blob/blobs/put_block_url.go | 129 ++++++++ .../2020-08-04/blob/blobs/put_page_blob.go | 148 +++++++++ .../2020-08-04/blob/blobs/put_page_clear.go | 113 +++++++ .../2020-08-04/blob/blobs/put_page_update.go | 164 +++++++++ .../2020-08-04/blob/blobs/resource_id.go | 56 ++++ .../storage/2020-08-04/blob/blobs/set_tier.go | 93 ++++++ .../storage/2020-08-04/blob/blobs/snapshot.go | 163 +++++++++ .../blob/blobs/snapshot_get_properties.go | 90 +++++ .../storage/2020-08-04/blob/blobs/undelete.go | 92 ++++++ .../storage/2020-08-04/blob/blobs/version.go | 14 + .../2020-08-04/blob/containers/README.md | 45 +++ .../storage/2020-08-04/blob/containers/api.go | 25 ++ .../2020-08-04/blob/containers/client.go | 34 ++ .../2020-08-04/blob/containers/create.go | 123 +++++++ .../2020-08-04/blob/containers/delete.go | 85 +++++ .../blob/containers/get_properties.go | 124 +++++++ .../blob/containers/lease_acquire.go | 115 +++++++ .../2020-08-04/blob/containers/lease_break.go | 129 ++++++++ .../blob/containers/lease_change.go | 111 +++++++ .../blob/containers/lease_release.go | 92 ++++++ .../2020-08-04/blob/containers/lease_renew.go | 92 ++++++ .../2020-08-04/blob/containers/list_blobs.go | 179 ++++++++++ .../2020-08-04/blob/containers/models.go | 75 +++++ .../2020-08-04/blob/containers/resource_id.go | 53 +++ .../2020-08-04/blob/containers/set_acl.go | 100 ++++++ .../blob/containers/set_metadata.go | 105 ++++++ .../2020-08-04/blob/containers/version.go | 14 + .../datalakestore/filesystems/README.md | 84 +++++ .../datalakestore/filesystems/client.go | 25 ++ .../datalakestore/filesystems/create.go | 94 ++++++ .../datalakestore/filesystems/delete.go | 85 +++++ .../datalakestore/filesystems/helpers.go | 40 +++ .../filesystems/properties_get.go | 112 +++++++ .../filesystems/properties_set.go | 109 ++++++ .../datalakestore/filesystems/resource_id.go | 46 +++ .../datalakestore/filesystems/version.go | 14 + .../2020-08-04/datalakestore/paths/client.go | 25 ++ .../2020-08-04/datalakestore/paths/create.go | 95 ++++++ .../2020-08-04/datalakestore/paths/delete.go | 81 +++++ .../2020-08-04/datalakestore/paths/helpers.go | 15 + .../datalakestore/paths/properties_get.go | 134 ++++++++ .../datalakestore/paths/properties_set.go | 116 +++++++ .../datalakestore/paths/resource_id.go | 57 ++++ .../2020-08-04/datalakestore/paths/version.go | 14 + .../2020-08-04/file/directories/README.md | 48 +++ .../2020-08-04/file/directories/api.go | 16 + .../2020-08-04/file/directories/client.go | 25 ++ .../2020-08-04/file/directories/create.go | 131 ++++++++ .../2020-08-04/file/directories/delete.go | 95 ++++++ .../2020-08-04/file/directories/get.go | 112 +++++++ .../file/directories/metadata_get.go | 106 ++++++ .../file/directories/metadata_set.go | 102 ++++++ .../file/directories/resource_id.go | 56 ++++ .../2020-08-04/file/directories/version.go | 14 + .../storage/2020-08-04/file/files/README.md | 47 +++ .../storage/2020-08-04/file/files/api.go | 28 ++ .../storage/2020-08-04/file/files/client.go | 25 ++ .../storage/2020-08-04/file/files/copy.go | 132 ++++++++ .../2020-08-04/file/files/copy_abort.go | 104 ++++++ .../2020-08-04/file/files/copy_wait.go | 55 ++++ .../storage/2020-08-04/file/files/create.go | 169 ++++++++++ .../storage/2020-08-04/file/files/delete.go | 94 ++++++ .../2020-08-04/file/files/metadata_get.go | 111 +++++++ .../2020-08-04/file/files/metadata_set.go | 105 ++++++ .../2020-08-04/file/files/properties_get.go | 144 ++++++++ .../2020-08-04/file/files/properties_set.go | 186 +++++++++++ .../2020-08-04/file/files/range_clear.go | 112 +++++++ .../2020-08-04/file/files/range_get.go | 121 +++++++ .../2020-08-04/file/files/range_get_file.go | 128 ++++++++ .../2020-08-04/file/files/range_put.go | 127 +++++++ .../2020-08-04/file/files/range_put_file.go | 107 ++++++ .../2020-08-04/file/files/ranges_list.go | 114 +++++++ .../2020-08-04/file/files/resource_id.go | 64 ++++ .../storage/2020-08-04/file/files/version.go | 14 + .../storage/2020-08-04/file/shares/README.md | 43 +++ .../storage/2020-08-04/file/shares/acl_get.go | 98 ++++++ .../storage/2020-08-04/file/shares/acl_set.go | 103 ++++++ .../storage/2020-08-04/file/shares/api.go | 24 ++ .../storage/2020-08-04/file/shares/client.go | 25 ++ .../storage/2020-08-04/file/shares/create.go | 109 ++++++ .../storage/2020-08-04/file/shares/delete.go | 94 ++++++ .../2020-08-04/file/shares/metadata_get.go | 102 ++++++ .../2020-08-04/file/shares/metadata_set.go | 97 ++++++ .../storage/2020-08-04/file/shares/models.go | 12 + .../2020-08-04/file/shares/properties_get.go | 113 +++++++ .../2020-08-04/file/shares/properties_set.go | 95 ++++++ .../2020-08-04/file/shares/resource_id.go | 53 +++ .../2020-08-04/file/shares/snapshot_create.go | 115 +++++++ .../2020-08-04/file/shares/snapshot_delete.go | 94 ++++++ .../2020-08-04/file/shares/snapshot_get.go | 105 ++++++ .../storage/2020-08-04/file/shares/stats.go | 100 ++++++ .../storage/2020-08-04/file/shares/version.go | 14 + .../storage/2020-08-04/queue/queues/README.md | 43 +++ .../storage/2020-08-04/queue/queues/api.go | 17 + .../storage/2020-08-04/queue/queues/client.go | 25 ++ .../storage/2020-08-04/queue/queues/create.go | 92 ++++++ .../storage/2020-08-04/queue/queues/delete.go | 85 +++++ .../2020-08-04/queue/queues/metadata_get.go | 101 ++++++ .../2020-08-04/queue/queues/metadata_set.go | 97 ++++++ .../storage/2020-08-04/queue/queues/models.go | 42 +++ .../2020-08-04/queue/queues/properties_get.go | 86 +++++ .../2020-08-04/queue/queues/properties_set.go | 81 +++++ .../2020-08-04/queue/queues/resource_id.go | 46 +++ .../2020-08-04/queue/queues/version.go | 14 + .../2020-08-04/table/entities/README.md | 48 +++ .../storage/2020-08-04/table/entities/api.go | 17 + .../2020-08-04/table/entities/client.go | 25 ++ .../2020-08-04/table/entities/delete.go | 99 ++++++ .../storage/2020-08-04/table/entities/get.go | 108 ++++++ .../2020-08-04/table/entities/insert.go | 112 +++++++ .../table/entities/insert_or_merge.go | 108 ++++++ .../table/entities/insert_or_replace.go | 108 ++++++ .../2020-08-04/table/entities/models.go | 9 + .../2020-08-04/table/entities/query.go | 162 +++++++++ .../2020-08-04/table/entities/resource_id.go | 91 +++++ .../2020-08-04/table/entities/version.go | 14 + .../storage/2020-08-04/table/tables/README.md | 39 +++ .../2020-08-04/table/tables/acl_get.go | 93 ++++++ .../2020-08-04/table/tables/acl_set.go | 98 ++++++ .../storage/2020-08-04/table/tables/api.go | 17 + .../storage/2020-08-04/table/tables/client.go | 25 ++ .../storage/2020-08-04/table/tables/create.go | 90 +++++ .../storage/2020-08-04/table/tables/delete.go | 79 +++++ .../storage/2020-08-04/table/tables/exists.go | 80 +++++ .../storage/2020-08-04/table/tables/models.go | 29 ++ .../storage/2020-08-04/table/tables/query.go | 87 +++++ .../2020-08-04/table/tables/resource_id.go | 54 +++ .../2020-08-04/table/tables/version.go | 14 + ...express_route_authorization.html.markdown} | 18 +- 171 files changed, 13904 insertions(+), 86 deletions(-) rename azurerm/internal/services/vmware/parse/{authorization.go => express_route_authorization.go} (52%) rename azurerm/internal/services/vmware/parse/{authorization_test.go => express_route_authorization_test.go} (76%) rename azurerm/internal/services/vmware/validate/{authorization_id.go => express_route_authorization_id.go} (70%) rename azurerm/internal/services/vmware/validate/{authorization_id_test.go => express_route_authorization_id_test.go} (91%) rename azurerm/internal/services/vmware/{vmware_authorization_resource.go => vmware_express_route_authorization_resource.go} (79%) rename azurerm/internal/services/vmware/{vmware_authorization_resource_test.go => vmware_express_route_authorization_resource_test.go} (61%) create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go create mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go rename website/docs/r/{vmware_authorization.html.markdown => vmware_express_route_authorization.html.markdown} (69%) diff --git a/azurerm/internal/services/vmware/parse/authorization.go b/azurerm/internal/services/vmware/parse/express_route_authorization.go similarity index 52% rename from azurerm/internal/services/vmware/parse/authorization.go rename to azurerm/internal/services/vmware/parse/express_route_authorization.go index 468243638836..3264a52b453d 100644 --- a/azurerm/internal/services/vmware/parse/authorization.go +++ b/azurerm/internal/services/vmware/parse/express_route_authorization.go @@ -9,45 +9,45 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure" ) -type AuthorizationId struct { - SubscriptionId string - ResourceGroup string - PrivateCloudName string - Name string +type ExpressRouteAuthorizationId struct { + SubscriptionId string + ResourceGroup string + PrivateCloudName string + AuthorizationName string } -func NewAuthorizationID(subscriptionId, resourceGroup, privateCloudName, name string) AuthorizationId { - return AuthorizationId{ - SubscriptionId: subscriptionId, - ResourceGroup: resourceGroup, - PrivateCloudName: privateCloudName, - Name: name, +func NewExpressRouteAuthorizationID(subscriptionId, resourceGroup, privateCloudName, authorizationName string) ExpressRouteAuthorizationId { + return ExpressRouteAuthorizationId{ + SubscriptionId: subscriptionId, + ResourceGroup: resourceGroup, + PrivateCloudName: privateCloudName, + AuthorizationName: authorizationName, } } -func (id AuthorizationId) String() string { +func (id ExpressRouteAuthorizationId) String() string { segments := []string{ - fmt.Sprintf("Name %q", id.Name), + fmt.Sprintf("Authorization Name %q", id.AuthorizationName), fmt.Sprintf("Private Cloud Name %q", id.PrivateCloudName), fmt.Sprintf("Resource Group %q", id.ResourceGroup), } segmentsStr := strings.Join(segments, " / ") - return fmt.Sprintf("%s: (%s)", "Authorization", segmentsStr) + return fmt.Sprintf("%s: (%s)", "Express Route Authorization", segmentsStr) } -func (id AuthorizationId) ID() string { +func (id ExpressRouteAuthorizationId) ID() string { fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.AVS/privateClouds/%s/authorizations/%s" - return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.PrivateCloudName, id.Name) + return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.PrivateCloudName, id.AuthorizationName) } -// AuthorizationID parses a Authorization ID into an AuthorizationId struct -func AuthorizationID(input string) (*AuthorizationId, error) { +// ExpressRouteAuthorizationID parses a ExpressRouteAuthorization ID into an ExpressRouteAuthorizationId struct +func ExpressRouteAuthorizationID(input string) (*ExpressRouteAuthorizationId, error) { id, err := azure.ParseAzureResourceID(input) if err != nil { return nil, err } - resourceId := AuthorizationId{ + resourceId := ExpressRouteAuthorizationId{ SubscriptionId: id.SubscriptionID, ResourceGroup: id.ResourceGroup, } @@ -63,7 +63,7 @@ func AuthorizationID(input string) (*AuthorizationId, error) { if resourceId.PrivateCloudName, err = id.PopSegment("privateClouds"); err != nil { return nil, err } - if resourceId.Name, err = id.PopSegment("authorizations"); err != nil { + if resourceId.AuthorizationName, err = id.PopSegment("authorizations"); err != nil { return nil, err } diff --git a/azurerm/internal/services/vmware/parse/authorization_test.go b/azurerm/internal/services/vmware/parse/express_route_authorization_test.go similarity index 76% rename from azurerm/internal/services/vmware/parse/authorization_test.go rename to azurerm/internal/services/vmware/parse/express_route_authorization_test.go index 1d7a54cb5eed..608d4953289a 100644 --- a/azurerm/internal/services/vmware/parse/authorization_test.go +++ b/azurerm/internal/services/vmware/parse/express_route_authorization_test.go @@ -8,21 +8,21 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/resourceid" ) -var _ resourceid.Formatter = AuthorizationId{} +var _ resourceid.Formatter = ExpressRouteAuthorizationId{} -func TestAuthorizationIDFormatter(t *testing.T) { - actual := NewAuthorizationID("12345678-1234-9876-4563-123456789012", "group1", "privateCloud1", "authorization1").ID() +func TestExpressRouteAuthorizationIDFormatter(t *testing.T) { + actual := NewExpressRouteAuthorizationID("12345678-1234-9876-4563-123456789012", "group1", "privateCloud1", "authorization1").ID() expected := "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1" if actual != expected { t.Fatalf("Expected %q but got %q", expected, actual) } } -func TestAuthorizationID(t *testing.T) { +func TestExpressRouteAuthorizationID(t *testing.T) { testData := []struct { Input string Error bool - Expected *AuthorizationId + Expected *ExpressRouteAuthorizationId }{ { @@ -68,13 +68,13 @@ func TestAuthorizationID(t *testing.T) { }, { - // missing Name + // missing AuthorizationName Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/", Error: true, }, { - // missing value for Name + // missing value for AuthorizationName Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/", Error: true, }, @@ -82,11 +82,11 @@ func TestAuthorizationID(t *testing.T) { { // valid Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1", - Expected: &AuthorizationId{ - SubscriptionId: "12345678-1234-9876-4563-123456789012", - ResourceGroup: "group1", - PrivateCloudName: "privateCloud1", - Name: "authorization1", + Expected: &ExpressRouteAuthorizationId{ + SubscriptionId: "12345678-1234-9876-4563-123456789012", + ResourceGroup: "group1", + PrivateCloudName: "privateCloud1", + AuthorizationName: "authorization1", }, }, @@ -100,7 +100,7 @@ func TestAuthorizationID(t *testing.T) { for _, v := range testData { t.Logf("[DEBUG] Testing %q", v.Input) - actual, err := AuthorizationID(v.Input) + actual, err := ExpressRouteAuthorizationID(v.Input) if err != nil { if v.Error { continue @@ -121,8 +121,8 @@ func TestAuthorizationID(t *testing.T) { if actual.PrivateCloudName != v.Expected.PrivateCloudName { t.Fatalf("Expected %q but got %q for PrivateCloudName", v.Expected.PrivateCloudName, actual.PrivateCloudName) } - if actual.Name != v.Expected.Name { - t.Fatalf("Expected %q but got %q for Name", v.Expected.Name, actual.Name) + if actual.AuthorizationName != v.Expected.AuthorizationName { + t.Fatalf("Expected %q but got %q for AuthorizationName", v.Expected.AuthorizationName, actual.AuthorizationName) } } } diff --git a/azurerm/internal/services/vmware/registration.go b/azurerm/internal/services/vmware/registration.go index b26e3a6f4cb0..04a86036168a 100644 --- a/azurerm/internal/services/vmware/registration.go +++ b/azurerm/internal/services/vmware/registration.go @@ -26,8 +26,8 @@ func (r Registration) SupportedDataSources() map[string]*schema.Resource { // SupportedResources returns the supported Resources supported by this Service func (r Registration) SupportedResources() map[string]*schema.Resource { return map[string]*schema.Resource{ - "azurerm_vmware_private_cloud": resourceVmwarePrivateCloud(), - "azurerm_vmware_cluster": resourceVmwareCluster(), - "azurerm_vmware_authorization": resourceVmwareAuthorization(), + "azurerm_vmware_private_cloud": resourceVmwarePrivateCloud(), + "azurerm_vmware_cluster": resourceVmwareCluster(), + "azurerm_vmware_express_route_authorization": resourceVmwareExpressRouteAuthorization(), } } diff --git a/azurerm/internal/services/vmware/resourceids.go b/azurerm/internal/services/vmware/resourceids.go index bae59ee0f644..36d2fe9d6a7c 100644 --- a/azurerm/internal/services/vmware/resourceids.go +++ b/azurerm/internal/services/vmware/resourceids.go @@ -2,4 +2,4 @@ package vmware //go:generate go run ../../tools/generator-resource-id/main.go -path=./ -name=PrivateCloud -id=/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1 //go:generate go run ../../tools/generator-resource-id/main.go -path=./ -name=Cluster -id=/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/clusters/cluster1 -//go:generate go run ../../tools/generator-resource-id/main.go -path=./ -name=Authorization -id=/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1 +//go:generate go run ../../tools/generator-resource-id/main.go -path=./ -name=ExpressRouteAuthorization -id=/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1 diff --git a/azurerm/internal/services/vmware/validate/authorization_id.go b/azurerm/internal/services/vmware/validate/express_route_authorization_id.go similarity index 70% rename from azurerm/internal/services/vmware/validate/authorization_id.go rename to azurerm/internal/services/vmware/validate/express_route_authorization_id.go index 8ed9489eed87..9c39daf76a0c 100644 --- a/azurerm/internal/services/vmware/validate/authorization_id.go +++ b/azurerm/internal/services/vmware/validate/express_route_authorization_id.go @@ -8,14 +8,14 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/vmware/parse" ) -func AuthorizationID(input interface{}, key string) (warnings []string, errors []error) { +func ExpressRouteAuthorizationID(input interface{}, key string) (warnings []string, errors []error) { v, ok := input.(string) if !ok { errors = append(errors, fmt.Errorf("expected %q to be a string", key)) return } - if _, err := parse.AuthorizationID(v); err != nil { + if _, err := parse.ExpressRouteAuthorizationID(v); err != nil { errors = append(errors, err) } diff --git a/azurerm/internal/services/vmware/validate/authorization_id_test.go b/azurerm/internal/services/vmware/validate/express_route_authorization_id_test.go similarity index 91% rename from azurerm/internal/services/vmware/validate/authorization_id_test.go rename to azurerm/internal/services/vmware/validate/express_route_authorization_id_test.go index 4e76d6c789ef..26ae035bf3f0 100644 --- a/azurerm/internal/services/vmware/validate/authorization_id_test.go +++ b/azurerm/internal/services/vmware/validate/express_route_authorization_id_test.go @@ -4,7 +4,7 @@ package validate import "testing" -func TestAuthorizationID(t *testing.T) { +func TestExpressRouteAuthorizationID(t *testing.T) { cases := []struct { Input string Valid bool @@ -53,13 +53,13 @@ func TestAuthorizationID(t *testing.T) { }, { - // missing Name + // missing AuthorizationName Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/", Valid: false, }, { - // missing value for Name + // missing value for AuthorizationName Input: "/subscriptions/12345678-1234-9876-4563-123456789012/resourceGroups/group1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/", Valid: false, }, @@ -78,7 +78,7 @@ func TestAuthorizationID(t *testing.T) { } for _, tc := range cases { t.Logf("[DEBUG] Testing Value %s", tc.Input) - _, errors := AuthorizationID(tc.Input, "test") + _, errors := ExpressRouteAuthorizationID(tc.Input, "test") valid := len(errors) == 0 if tc.Valid != valid { diff --git a/azurerm/internal/services/vmware/vmware_authorization_resource.go b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource.go similarity index 79% rename from azurerm/internal/services/vmware/vmware_authorization_resource.go rename to azurerm/internal/services/vmware/vmware_express_route_authorization_resource.go index 3410f074b71e..242cead1239b 100644 --- a/azurerm/internal/services/vmware/vmware_authorization_resource.go +++ b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource.go @@ -17,11 +17,11 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) -func resourceVmwareAuthorization() *schema.Resource { +func resourceVmwareExpressRouteAuthorization() *schema.Resource { return &schema.Resource{ - Create: resourceVmwareAuthorizationCreate, - Read: resourceVmwareAuthorizationRead, - Delete: resourceVmwareAuthorizationDelete, + Create: resourceVmwareExpressRouteAuthorizationCreate, + Read: resourceVmwareExpressRouteAuthorizationRead, + Delete: resourceVmwareExpressRouteAuthorizationDelete, Timeouts: &schema.ResourceTimeout{ Create: schema.DefaultTimeout(30 * time.Minute), @@ -30,7 +30,7 @@ func resourceVmwareAuthorization() *schema.Resource { }, Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { - _, err := parse.AuthorizationID(id) + _, err := parse.ExpressRouteAuthorizationID(id) return err }), @@ -62,7 +62,7 @@ func resourceVmwareAuthorization() *schema.Resource { }, } } -func resourceVmwareAuthorizationCreate(d *schema.ResourceData, meta interface{}) error { +func resourceVmwareExpressRouteAuthorizationCreate(d *schema.ResourceData, meta interface{}) error { subscriptionId := meta.(*clients.Client).Account.SubscriptionId client := meta.(*clients.Client).Vmware.AuthorizationClient ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) @@ -74,16 +74,16 @@ func resourceVmwareAuthorizationCreate(d *schema.ResourceData, meta interface{}) return err } - id := parse.NewAuthorizationID(subscriptionId, privateCloudId.ResourceGroup, privateCloudId.Name, name) + id := parse.NewExpressRouteAuthorizationID(subscriptionId, privateCloudId.ResourceGroup, privateCloudId.Name, name) - existing, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + existing, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.AuthorizationName) if err != nil { if !utils.ResponseWasNotFound(existing.Response) { return fmt.Errorf("checking for present of existing %q : %+v", id.ID(), err) } } if !utils.ResponseWasNotFound(existing.Response) { - return tf.ImportAsExistsError("azurerm_vmware_authorization", id.ID()) + return tf.ImportAsExistsError("azurerm_vmware_express_route_authorization", id.ID()) } props := avs.ExpressRouteAuthorization{} @@ -98,21 +98,21 @@ func resourceVmwareAuthorizationCreate(d *schema.ResourceData, meta interface{}) } d.SetId(id.ID()) - return resourceVmwareAuthorizationRead(d, meta) + return resourceVmwareExpressRouteAuthorizationRead(d, meta) } -func resourceVmwareAuthorizationRead(d *schema.ResourceData, meta interface{}) error { +func resourceVmwareExpressRouteAuthorizationRead(d *schema.ResourceData, meta interface{}) error { subscriptionId := meta.(*clients.Client).Account.SubscriptionId client := meta.(*clients.Client).Vmware.AuthorizationClient ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) defer cancel() - id, err := parse.AuthorizationID(d.Id()) + id, err := parse.ExpressRouteAuthorizationID(d.Id()) if err != nil { return err } - resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + resp, err := client.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.AuthorizationName) if err != nil { if utils.ResponseWasNotFound(resp.Response) { log.Printf("[INFO] avs %q does not exist - removing from state", d.Id()) @@ -122,7 +122,7 @@ func resourceVmwareAuthorizationRead(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("retrieving %q: %+v", id, err) } - d.Set("name", id.Name) + d.Set("name", id.AuthorizationName) d.Set("private_cloud_id", parse.NewPrivateCloudID(subscriptionId, id.ResourceGroup, id.PrivateCloudName).ID()) if props := resp.ExpressRouteAuthorizationProperties; props != nil { d.Set("express_route_authorization_id", props.ExpressRouteAuthorizationID) @@ -131,17 +131,17 @@ func resourceVmwareAuthorizationRead(d *schema.ResourceData, meta interface{}) e return nil } -func resourceVmwareAuthorizationDelete(d *schema.ResourceData, meta interface{}) error { +func resourceVmwareExpressRouteAuthorizationDelete(d *schema.ResourceData, meta interface{}) error { client := meta.(*clients.Client).Vmware.AuthorizationClient ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) defer cancel() - id, err := parse.AuthorizationID(d.Id()) + id, err := parse.ExpressRouteAuthorizationID(d.Id()) if err != nil { return err } - future, err := client.Delete(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + future, err := client.Delete(ctx, id.ResourceGroup, id.PrivateCloudName, id.AuthorizationName) if err != nil { return fmt.Errorf("deleting %q: %+v", id, err) } diff --git a/azurerm/internal/services/vmware/vmware_authorization_resource_test.go b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource_test.go similarity index 61% rename from azurerm/internal/services/vmware/vmware_authorization_resource_test.go rename to azurerm/internal/services/vmware/vmware_express_route_authorization_resource_test.go index b3f9f0d89172..fbef5930b197 100644 --- a/azurerm/internal/services/vmware/vmware_authorization_resource_test.go +++ b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource_test.go @@ -14,12 +14,12 @@ import ( "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) -type VmwareAuthorizationResource struct { +type VmwareExpressRouteAuthorizationResource struct { } -func TestAccVmwareAuthorization_basic(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_vmware_authorization", "test") - r := VmwareAuthorizationResource{} +func TestAccVmwareExpressRouteAuthorization_basic(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_vmware_express_route_authorization", "test") + r := VmwareExpressRouteAuthorizationResource{} data.ResourceTest(t, r, []resource.TestStep{ { @@ -34,9 +34,9 @@ func TestAccVmwareAuthorization_basic(t *testing.T) { }) } -func TestAccVmwareAuthorization_requiresImport(t *testing.T) { - data := acceptance.BuildTestData(t, "azurerm_vmware_authorization", "test") - r := VmwareAuthorizationResource{} +func TestAccVmwareExpressRouteAuthorization_requiresImport(t *testing.T) { + data := acceptance.BuildTestData(t, "azurerm_vmware_express_route_authorization", "test") + r := VmwareExpressRouteAuthorizationResource{} data.ResourceTest(t, r, []resource.TestStep{ { @@ -49,13 +49,13 @@ func TestAccVmwareAuthorization_requiresImport(t *testing.T) { }) } -func (VmwareAuthorizationResource) Exists(ctx context.Context, clients *clients.Client, state *terraform.InstanceState) (*bool, error) { - id, err := parse.AuthorizationID(state.ID) +func (VmwareExpressRouteAuthorizationResource) Exists(ctx context.Context, clients *clients.Client, state *terraform.InstanceState) (*bool, error) { + id, err := parse.ExpressRouteAuthorizationID(state.ID) if err != nil { return nil, err } - resp, err := clients.Vmware.AuthorizationClient.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.Name) + resp, err := clients.Vmware.AuthorizationClient.Get(ctx, id.ResourceGroup, id.PrivateCloudName, id.AuthorizationName) if err != nil { return nil, fmt.Errorf("retrieving %q: %+v", id, err) } @@ -63,23 +63,23 @@ func (VmwareAuthorizationResource) Exists(ctx context.Context, clients *clients. return utils.Bool(resp.ExpressRouteAuthorizationProperties != nil), nil } -func (r VmwareAuthorizationResource) basic(data acceptance.TestData) string { +func (r VmwareExpressRouteAuthorizationResource) basic(data acceptance.TestData) string { return fmt.Sprintf(` %s -resource "azurerm_vmware_authorization" "test" { +resource "azurerm_vmware_express_route_authorization" "test" { name = "acctest-VmwareAuthorization-%d" private_cloud_id = azurerm_vmware_private_cloud.test.id } `, VmwarePrivateCloudResource{}.basic(data), data.RandomInteger) } -func (r VmwareAuthorizationResource) requiresImport(data acceptance.TestData) string { +func (r VmwareExpressRouteAuthorizationResource) requiresImport(data acceptance.TestData) string { return fmt.Sprintf(` %s -resource "azurerm_vmware_authorization" "import" { - name = azurerm_vmware_authorization.test.name +resource "azurerm_vmware_express_route_authorization" "import" { + name = azurerm_vmware_express_route_authorization.test.name private_cloud_id = azurerm_vmware_private_cloud.test.id } `, r.basic(data)) diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md new file mode 100644 index 000000000000..5fa24a74e9bb --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md @@ -0,0 +1,57 @@ +## Blob Storage Account SDK for API version 2020-08-04 + +This package allows you to interact with the Accounts Blob Storage API + +### Supported Authorizers + +* Azure Active Directory + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts" +) + +func Example() error { + accountName := "storageaccount1" + + // e.g. https://github.com/tombuildsstuff/giovanni/blob/76f5f686c99ecdcc3fa533a0330d0e1aacb1c327/example/azuread-auth/main.go#L54 + client, err := buildClient() + if err != nil { + return fmt.Errorf("error building client: %s", err) + } + + ctx := context.TODO() + + input := StorageServiceProperties{ + StaticWebsite: &StaticWebsite{ + Enabled: true, + IndexDocument: index, + ErrorDocument404Path: errorDocument, + }, + } + + _, err = client.SetServiceProperties(ctx, accountName, input) + if err != nil { + return fmt.Errorf("error setting properties: %s", err) + } + + time.Sleep(2 * time.Second) + + _, err = accountsClient.GetServiceProperties(ctx, accountName) + if err != nil { + return fmt.Errorf("error getting properties: %s", err) + } + + return nil +} + +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go new file mode 100644 index 000000000000..0162ebbb0c33 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go @@ -0,0 +1,25 @@ +package accounts + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Blob Storage Blobs. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithBaseURI creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go new file mode 100644 index 000000000000..e622fff3ba46 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go @@ -0,0 +1,84 @@ +package accounts + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetServicePropertiesResult struct { + autorest.Response + + ContentType string + StorageServiceProperties *StorageServiceProperties +} + +// GetServicePropertiesPreparer prepares the GetServiceProperties request. +func (client Client) GetServicePropertiesPreparer(ctx context.Context, accountName string) (*http.Request, error) { + queryParameters := map[string]interface{}{ + "restype": "service", + "comp": "properties", + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +func (client Client) GetServicePropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +func (client Client) GetServicePropertiesResponder(resp *http.Response) (result GetServicePropertiesResult, err error) { + if resp != nil && resp.Header != nil { + result.ContentType = resp.Header.Get("Content-Type") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result.StorageServiceProperties), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +func (client Client) GetServiceProperties(ctx context.Context, accountName string) (result GetServicePropertiesResult, err error) { + if accountName == "" { + return result, validation.NewError("accounts.Client", "GetServiceProperties", "`accountName` cannot be an empty string.") + } + + req, err := client.GetServicePropertiesPreparer(ctx, accountName) + if err != nil { + err = autorest.NewErrorWithError(err, "accounts.Client", "GetServiceProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetServicePropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "accounts.Client", "GetServiceProperties", resp, "Failure sending request") + return + } + + result, err = client.GetServicePropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "accounts.Client", "GetServiceProperties", resp, "Failure responding to request") + return + } + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go new file mode 100644 index 000000000000..3a2891439bee --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go @@ -0,0 +1,80 @@ +package accounts + +import "github.com/Azure/go-autorest/autorest" + +type SetServicePropertiesResult struct { + autorest.Response +} + +type StorageServiceProperties struct { + // Cors - Specifies CORS rules for the Blob service. You can include up to five CorsRule elements in the request. If no CorsRule elements are included in the request body, all CORS rules will be deleted, and CORS will be disabled for the Blob service. + Cors *CorsRules `xml:"Cors,omitempty"` + // DefaultServiceVersion - DefaultServiceVersion indicates the default version to use for requests to the Blob service if an incoming request’s version is not specified. Possible values include version 2008-10-27 and all more recent versions. + DefaultServiceVersion *string `xml:"DefaultServiceVersion,omitempty"` + // DeleteRetentionPolicy - The blob service properties for soft delete. + DeleteRetentionPolicy *DeleteRetentionPolicy `xml:"DeleteRetentionPolicy,omitempty"` + // Logging - The blob service properties for logging access + Logging *Logging `xml:"Logging,omitempty"` + // HourMetrics - The blob service properties for hour metrics + HourMetrics *MetricsConfig `xml:"HourMetrics,omitempty"` + // HourMetrics - The blob service properties for minute metrics + MinuteMetrics *MetricsConfig `xml:"MinuteMetrics,omitempty"` + // StaticWebsite - Optional + StaticWebsite *StaticWebsite `xml:"StaticWebsite,omitempty"` +} + +// StaticWebsite sets the static website support properties on the Blob service. +type StaticWebsite struct { + // Enabled - Required. Indicates whether static website support is enabled for the given account. + Enabled bool `xml:"Enabled"` + // IndexDocument - Optional. The webpage that Azure Storage serves for requests to the root of a website or any subfolder. For example, index.html. The value is case-sensitive. + IndexDocument string `xml:"IndexDocument,omitempty"` + // ErrorDocument404Path - Optional. The absolute path to a webpage that Azure Storage serves for requests that do not correspond to an existing file. For example, error/404.html. Only a single custom 404 page is supported in each static website. The value is case-sensitive. + ErrorDocument404Path string `xml:"ErrorDocument404Path,omitempty"` +} + +// CorsRules sets the CORS rules. You can include up to five CorsRule elements in the request. +type CorsRules struct { + // CorsRules - The List of CORS rules. You can include up to five CorsRule elements in the request. + CorsRules []CorsRule `xml:"CorsRules,omitempty"` +} + +// DeleteRetentionPolicy the blob service properties for soft delete. +type DeleteRetentionPolicy struct { + // Enabled - Indicates whether DeleteRetentionPolicy is enabled for the Blob service. + Enabled bool `xml:"Enabled,omitempty"` + // Days - Indicates the number of days that the deleted blob should be retained. The minimum specified value can be 1 and the maximum value can be 365. + Days int32 `xml:"Days,omitempty"` +} + +// CorsRule specifies a CORS rule for the Blob service. +type CorsRule struct { + // AllowedOrigins - Required if CorsRule element is present. A list of origin domains that will be allowed via CORS, or "" to allow all domains + AllowedOrigins []string `xml:"AllowedOrigins,omitempty"` + // AllowedMethods - Required if CorsRule element is present. A list of HTTP methods that are allowed to be executed by the origin. + AllowedMethods []string `xml:"AllowedMethods,omitempty"` + // MaxAgeInSeconds - Required if CorsRule element is present. The number of seconds that the client/browser should cache a preflight response. + MaxAgeInSeconds int32 `xml:"MaxAgeInSeconds,omitempty"` + // ExposedHeaders - Required if CorsRule element is present. A list of response headers to expose to CORS clients. + ExposedHeaders []string `xml:"ExposedHeaders,omitempty"` + // AllowedHeaders - Required if CorsRule element is present. A list of headers allowed to be part of the cross-origin request. + AllowedHeaders []string `xml:"AllowedHeaders,omitempty"` +} + +// Logging specifies the access logging options for the Blob service. +type Logging struct { + Version string `xml:"Version"` + Delete bool `xml:"Delete"` + Read bool `xml:"Read"` + Write bool `xml:"Write"` + RetentionPolicy DeleteRetentionPolicy `xml:"RetentionPolicy"` +} + +// MetricsConfig specifies the hour and/or minute metrics options for the Blob service. +// Elements are all expected +type MetricsConfig struct { + Version string `xml:"Version"` + Enabled bool `xml:"Enabled"` + RetentionPolicy DeleteRetentionPolicy `xml:"RetentionPolicy"` + IncludeAPIs bool `xml:"IncludeAPIs"` +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go new file mode 100644 index 000000000000..17b7bcc7e763 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go @@ -0,0 +1,77 @@ +package accounts + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetServicePropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetServicePropertiesPreparer prepares the SetServiceProperties request. +func (client Client) SetServicePropertiesPreparer(ctx context.Context, accountName string, input StorageServiceProperties) (*http.Request, error) { + queryParameters := map[string]interface{}{ + "restype": "service", + "comp": "properties", + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithHeaders(headers), + autorest.WithXML(input), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always +// closes the http.Response Body. +func (client Client) SetServicePropertiesResponder(resp *http.Response) (result SetServicePropertiesResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +func (client Client) SetServiceProperties(ctx context.Context, accountName string, input StorageServiceProperties) (result SetServicePropertiesResult, err error) { + if accountName == "" { + return result, validation.NewError("accounts.Client", "SetServiceProperties", "`accountName` cannot be an empty string.") + } + + req, err := client.SetServicePropertiesPreparer(ctx, accountName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "accounts.Client", "SetServiceProperties", nil, "Failure preparing request") + return + } + + resp, err := client.SetServicePropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "accounts.Client", "SetServiceProperties", resp, "Failure sending request") + return + } + + result, err = client.SetServicePropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "accounts.Client", "SetServiceProperties", resp, "Failure responding to request") + return + } + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go new file mode 100644 index 000000000000..3d6d01147003 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go @@ -0,0 +1,14 @@ +package accounts + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md new file mode 100644 index 000000000000..19218cf9fd85 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md @@ -0,0 +1,46 @@ +## Blob Storage Blobs SDK for API version 2020-08-04 + +This package allows you to interact with the Blobs Blob Storage API + +### Supported Authorizers + +* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) +* SharedKeyLite (Blob, File & Queue) + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + containerName := "mycontainer" + fileName := "example-large-file.iso" + + storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) + blobClient := blobs.New() + blobClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + copyInput := blobs.CopyInput{ + CopySource: "http://releases.ubuntu.com/14.04/ubuntu-14.04.6-desktop-amd64.iso", + } + refreshInterval := 5 * time.Second + if err := blobClient.CopyAndWait(ctx, accountName, containerName, fileName, copyInput, refreshInterval); err != nil { + return fmt.Errorf("Error copying: %s", err) + } + + return nil +} + +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go new file mode 100644 index 000000000000..7e4f6494c2d1 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go @@ -0,0 +1,45 @@ +package blobs + +import ( + "context" + "os" + "time" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageBlob interface { + AppendBlock(ctx context.Context, accountName, containerName, blobName string, input AppendBlockInput) (result AppendBlockResult, err error) + Copy(ctx context.Context, accountName, containerName, blobName string, input CopyInput) (result CopyResult, err error) + AbortCopy(ctx context.Context, accountName, containerName, blobName string, input AbortCopyInput) (result autorest.Response, err error) + CopyAndWait(ctx context.Context, accountName, containerName, blobName string, input CopyInput, pollingInterval time.Duration) error + Delete(ctx context.Context, accountName, containerName, blobName string, input DeleteInput) (result autorest.Response, err error) + DeleteSnapshot(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotInput) (result autorest.Response, err error) + DeleteSnapshots(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotsInput) (result autorest.Response, err error) + Get(ctx context.Context, accountName, containerName, blobName string, input GetInput) (result GetResult, err error) + GetBlockList(ctx context.Context, accountName, containerName, blobName string, input GetBlockListInput) (result GetBlockListResult, err error) + GetPageRanges(ctx context.Context, accountName, containerName, blobName string, input GetPageRangesInput) (result GetPageRangesResult, err error) + IncrementalCopyBlob(ctx context.Context, accountName, containerName, blobName string, input IncrementalCopyBlobInput) (result autorest.Response, err error) + AcquireLease(ctx context.Context, accountName, containerName, blobName string, input AcquireLeaseInput) (result AcquireLeaseResult, err error) + BreakLease(ctx context.Context, accountName, containerName, blobName string, input BreakLeaseInput) (result autorest.Response, err error) + ChangeLease(ctx context.Context, accountName, containerName, blobName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) + ReleaseLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) + RenewLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) + SetMetaData(ctx context.Context, accountName, containerName, blobName string, input SetMetaDataInput) (result autorest.Response, err error) + GetProperties(ctx context.Context, accountName, containerName, blobName string, input GetPropertiesInput) (result GetPropertiesResult, err error) + SetProperties(ctx context.Context, accountName, containerName, blobName string, input SetPropertiesInput) (result SetPropertiesResult, err error) + PutAppendBlob(ctx context.Context, accountName, containerName, blobName string, input PutAppendBlobInput) (result autorest.Response, err error) + PutBlock(ctx context.Context, accountName, containerName, blobName string, input PutBlockInput) (result PutBlockResult, err error) + PutBlockBlob(ctx context.Context, accountName, containerName, blobName string, input PutBlockBlobInput) (result autorest.Response, err error) + PutBlockBlobFromFile(ctx context.Context, accountName, containerName, blobName string, file *os.File, input PutBlockBlobInput) error + PutBlockList(ctx context.Context, accountName, containerName, blobName string, input PutBlockListInput) (result PutBlockListResult, err error) + PutBlockFromURL(ctx context.Context, accountName, containerName, blobName string, input PutBlockFromURLInput) (result PutBlockFromURLResult, err error) + PutPageBlob(ctx context.Context, accountName, containerName, blobName string, input PutPageBlobInput) (result autorest.Response, err error) + PutPageClear(ctx context.Context, accountName, containerName, blobName string, input PutPageClearInput) (result autorest.Response, err error) + PutPageUpdate(ctx context.Context, accountName, containerName, blobName string, input PutPageUpdateInput) (result PutPageUpdateResult, err error) + GetResourceID(accountName, containerName, blobName string) string + SetTier(ctx context.Context, accountName, containerName, blobName string, tier AccessTier) (result autorest.Response, err error) + Snapshot(ctx context.Context, accountName, containerName, blobName string, input SnapshotInput) (result SnapshotResult, err error) + GetSnapshotProperties(ctx context.Context, accountName, containerName, blobName string, input GetSnapshotPropertiesInput) (result GetPropertiesResult, err error) + Undelete(ctx context.Context, accountName, containerName, blobName string) (result autorest.Response, err error) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go new file mode 100644 index 000000000000..b7705c202518 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go @@ -0,0 +1,180 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strconv" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type AppendBlockInput struct { + + // A number indicating the byte offset to compare. + // Append Block will succeed only if the append position is equal to this number. + // If it is not, the request will fail with an AppendPositionConditionNotMet + // error (HTTP status code 412 – Precondition Failed) + BlobConditionAppendPosition *int64 + + // The max length in bytes permitted for the append blob. + // If the Append Block operation would cause the blob to exceed that limit or if the blob size + // is already greater than the value specified in this header, the request will fail with + // an MaxBlobSizeConditionNotMet error (HTTP status code 412 – Precondition Failed). + BlobConditionMaxSize *int64 + + // The Bytes which should be appended to the end of this Append Blob. + // This can either be nil, which creates an empty blob, or a byte array + Content *[]byte + + // An MD5 hash of the block content. + // This hash is used to verify the integrity of the block during transport. + // When this header is specified, the storage service compares the hash of the content + // that has arrived with this header value. + // + // Note that this MD5 hash is not stored with the blob. + // If the two hashes do not match, the operation will fail with error code 400 (Bad Request). + ContentMD5 *string + + // Required if the blob has an active lease. + // To perform this operation on a blob with an active lease, specify the valid lease ID for this header. + LeaseID *string +} + +type AppendBlockResult struct { + autorest.Response + + BlobAppendOffset string + BlobCommittedBlockCount int64 + ContentMD5 string + ETag string + LastModified string +} + +// AppendBlock commits a new block of data to the end of an existing append blob. +func (client Client) AppendBlock(ctx context.Context, accountName, containerName, blobName string, input AppendBlockInput) (result AppendBlockResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "AppendBlock", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "AppendBlock", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "AppendBlock", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "AppendBlock", "`blobName` cannot be an empty string.") + } + if input.Content != nil && len(*input.Content) > (4*1024*1024) { + return result, validation.NewError("files.Client", "PutByteRange", "`input.Content` must be at most 4MB.") + } + + req, err := client.AppendBlockPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "AppendBlock", nil, "Failure preparing request") + return + } + + resp, err := client.AppendBlockSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "AppendBlock", resp, "Failure sending request") + return + } + + result, err = client.AppendBlockResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "AppendBlock", resp, "Failure responding to request") + return + } + + return +} + +// AppendBlockPreparer prepares the AppendBlock request. +func (client Client) AppendBlockPreparer(ctx context.Context, accountName, containerName, blobName string, input AppendBlockInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "appendblock"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.BlobConditionAppendPosition != nil { + headers["x-ms-blob-condition-appendpos"] = *input.BlobConditionAppendPosition + } + if input.BlobConditionMaxSize != nil { + headers["x-ms-blob-condition-maxsize"] = *input.BlobConditionMaxSize + } + if input.ContentMD5 != nil { + headers["x-ms-blob-content-md5"] = *input.ContentMD5 + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + if input.Content != nil { + headers["Content-Length"] = int(len(*input.Content)) + } + + decorators := []autorest.PrepareDecorator{ + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers), + } + + if input.Content != nil { + decorators = append(decorators, autorest.WithBytes(input.Content)) + } + + preparer := autorest.CreatePreparer(decorators...) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// AppendBlockSender sends the AppendBlock request. The method will close the +// http.Response Body if it receives an error. +func (client Client) AppendBlockSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// AppendBlockResponder handles the response to the AppendBlock request. The method always +// closes the http.Response Body. +func (client Client) AppendBlockResponder(resp *http.Response) (result AppendBlockResult, err error) { + if resp != nil && resp.Header != nil { + result.BlobAppendOffset = resp.Header.Get("x-ms-blob-append-offset") + result.ContentMD5 = resp.Header.Get("ETag") + result.ETag = resp.Header.Get("ETag") + result.LastModified = resp.Header.Get("Last-Modified") + + if v := resp.Header.Get("x-ms-blob-committed-block-count"); v != "" { + i, innerErr := strconv.Atoi(v) + if innerErr != nil { + err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) + return + } + + result.BlobCommittedBlockCount = int64(i) + } + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go new file mode 100644 index 000000000000..db20391922bb --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go @@ -0,0 +1,25 @@ +package blobs + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Blob Storage Blobs. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithBaseURI creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go new file mode 100644 index 000000000000..febaab5f9a91 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go @@ -0,0 +1,235 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type CopyInput struct { + // Specifies the name of the source blob or file. + // Beginning with version 2012-02-12, this value may be a URL of up to 2 KB in length that specifies a blob. + // The value should be URL-encoded as it would appear in a request URI. + // A source blob in the same storage account can be authenticated via Shared Key. + // However, if the source is a blob in another account, + // the source blob must either be public or must be authenticated via a shared access signature. + // If the source blob is public, no authentication is required to perform the copy operation. + // + // Beginning with version 2015-02-21, the source object may be a file in the Azure File service. + // If the source object is a file that is to be copied to a blob, then the source file must be authenticated + // using a shared access signature, whether it resides in the same account or in a different account. + // + // Only storage accounts created on or after June 7th, 2012 allow the Copy Blob operation to + // copy from another storage account. + CopySource string + + // The ID of the Lease + // Required if the destination blob has an active lease. + // The lease ID specified for this header must match the lease ID of the destination blob. + // If the request does not include the lease ID or it is not valid, + // the operation fails with status code 412 (Precondition Failed). + // + // If this header is specified and the destination blob does not currently have an active lease, + // the operation will also fail with status code 412 (Precondition Failed). + LeaseID *string + + // The ID of the Lease on the Source Blob + // Specify to perform the Copy Blob operation only if the lease ID matches the active lease ID of the source blob. + SourceLeaseID *string + + // For page blobs on a premium account only. Specifies the tier to be set on the target blob + AccessTier *AccessTier + + // A user-defined name-value pair associated with the blob. + // If no name-value pairs are specified, the operation will copy the metadata from the source blob or + // file to the destination blob. + // If one or more name-value pairs are specified, the destination blob is created with the specified metadata, + // and metadata is not copied from the source blob or file. + MetaData map[string]string + + // An ETag value. + // Specify an ETag value for this conditional header to copy the blob only if the specified + // ETag value matches the ETag value for an existing destination blob. + // If the ETag for the destination blob does not match the ETag specified for If-Match, + // the Blob service returns status code 412 (Precondition Failed). + IfMatch *string + + // An ETag value, or the wildcard character (*). + // Specify an ETag value for this conditional header to copy the blob only if the specified + // ETag value does not match the ETag value for the destination blob. + // Specify the wildcard character (*) to perform the operation only if the destination blob does not exist. + // If the specified condition isn't met, the Blob service returns status code 412 (Precondition Failed). + IfNoneMatch *string + + // A DateTime value. + // Specify this conditional header to copy the blob only if the destination blob + // has been modified since the specified date/time. + // If the destination blob has not been modified, the Blob service returns status code 412 (Precondition Failed). + IfModifiedSince *string + + // A DateTime value. + // Specify this conditional header to copy the blob only if the destination blob + // has not been modified since the specified date/time. + // If the destination blob has been modified, the Blob service returns status code 412 (Precondition Failed). + IfUnmodifiedSince *string + + // An ETag value. + // Specify this conditional header to copy the source blob only if its ETag matches the value specified. + // If the ETag values do not match, the Blob service returns status code 412 (Precondition Failed). + // This cannot be specified if the source is an Azure File. + SourceIfMatch *string + + // An ETag value. + // Specify this conditional header to copy the blob only if its ETag does not match the value specified. + // If the values are identical, the Blob service returns status code 412 (Precondition Failed). + // This cannot be specified if the source is an Azure File. + SourceIfNoneMatch *string + + // A DateTime value. + // Specify this conditional header to copy the blob only if the source blob has been modified + // since the specified date/time. + // If the source blob has not been modified, the Blob service returns status code 412 (Precondition Failed). + // This cannot be specified if the source is an Azure File. + SourceIfModifiedSince *string + + // A DateTime value. + // Specify this conditional header to copy the blob only if the source blob has not been modified + // since the specified date/time. + // If the source blob has been modified, the Blob service returns status code 412 (Precondition Failed). + // This header cannot be specified if the source is an Azure File. + SourceIfUnmodifiedSince *string +} + +type CopyResult struct { + autorest.Response + + CopyID string + CopyStatus string +} + +// Copy copies a blob to a destination within the storage account asynchronously. +func (client Client) Copy(ctx context.Context, accountName, containerName, blobName string, input CopyInput) (result CopyResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "Copy", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "Copy", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "Copy", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "Copy", "`blobName` cannot be an empty string.") + } + if input.CopySource == "" { + return result, validation.NewError("blobs.Client", "Copy", "`input.CopySource` cannot be an empty string.") + } + + req, err := client.CopyPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Copy", nil, "Failure preparing request") + return + } + + resp, err := client.CopySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "Copy", resp, "Failure sending request") + return + } + + result, err = client.CopyResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Copy", resp, "Failure responding to request") + return + } + + return +} + +// CopyPreparer prepares the Copy request. +func (client Client) CopyPreparer(ctx context.Context, accountName, containerName, blobName string, input CopyInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-copy-source": autorest.Encode("header", input.CopySource), + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + if input.SourceLeaseID != nil { + headers["x-ms-source-lease-id"] = *input.SourceLeaseID + } + if input.AccessTier != nil { + headers["x-ms-access-tier"] = string(*input.AccessTier) + } + + if input.IfMatch != nil { + headers["If-Match"] = *input.IfMatch + } + if input.IfNoneMatch != nil { + headers["If-None-Match"] = *input.IfNoneMatch + } + if input.IfUnmodifiedSince != nil { + headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince + } + if input.IfModifiedSince != nil { + headers["If-Modified-Since"] = *input.IfModifiedSince + } + + if input.SourceIfMatch != nil { + headers["x-ms-source-if-match"] = *input.SourceIfMatch + } + if input.SourceIfNoneMatch != nil { + headers["x-ms-source-if-none-match"] = *input.SourceIfNoneMatch + } + if input.SourceIfModifiedSince != nil { + headers["x-ms-source-if-modified-since"] = *input.SourceIfModifiedSince + } + if input.SourceIfUnmodifiedSince != nil { + headers["x-ms-source-if-unmodified-since"] = *input.SourceIfUnmodifiedSince + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CopySender sends the Copy request. The method will close the +// http.Response Body if it receives an error. +func (client Client) CopySender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CopyResponder handles the response to the Copy request. The method always +// closes the http.Response Body. +func (client Client) CopyResponder(resp *http.Response) (result CopyResult, err error) { + if resp != nil && resp.Header != nil { + result.CopyID = resp.Header.Get("x-ms-copy-id") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go new file mode 100644 index 000000000000..a992ff199bb1 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go @@ -0,0 +1,110 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type AbortCopyInput struct { + // The Copy ID which should be aborted + CopyID string + + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string +} + +// AbortCopy aborts a pending Copy Blob operation, and leaves a destination blob with zero length and full metadata. +func (client Client) AbortCopy(ctx context.Context, accountName, containerName, blobName string, input AbortCopyInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "AbortCopy", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "AbortCopy", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "AbortCopy", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "AbortCopy", "`blobName` cannot be an empty string.") + } + if input.CopyID == "" { + return result, validation.NewError("blobs.Client", "AbortCopy", "`input.CopyID` cannot be an empty string.") + } + + req, err := client.AbortCopyPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "AbortCopy", nil, "Failure preparing request") + return + } + + resp, err := client.AbortCopySender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "AbortCopy", resp, "Failure sending request") + return + } + + result, err = client.AbortCopyResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "AbortCopy", resp, "Failure responding to request") + return + } + + return +} + +// AbortCopyPreparer prepares the AbortCopy request. +func (client Client) AbortCopyPreparer(ctx context.Context, accountName, containerName, blobName string, input AbortCopyInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "copy"), + "copyid": autorest.Encode("query", input.CopyID), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-copy-action": "abort", + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// AbortCopySender sends the AbortCopy request. The method will close the +// http.Response Body if it receives an error. +func (client Client) AbortCopySender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// AbortCopyResponder handles the response to the AbortCopy request. The method always +// closes the http.Response Body. +func (client Client) AbortCopyResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go new file mode 100644 index 000000000000..a1e7fa453dc0 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go @@ -0,0 +1,41 @@ +package blobs + +import ( + "context" + "fmt" + "time" +) + +// CopyAndWait copies a blob to a destination within the storage account and waits for it to finish copying. +func (client Client) CopyAndWait(ctx context.Context, accountName, containerName, blobName string, input CopyInput, pollingInterval time.Duration) error { + if _, err := client.Copy(ctx, accountName, containerName, blobName, input); err != nil { + return fmt.Errorf("Error copying: %s", err) + } + + for true { + getInput := GetPropertiesInput{ + LeaseID: input.LeaseID, + } + getResult, err := client.GetProperties(ctx, accountName, containerName, blobName, getInput) + if err != nil { + return fmt.Errorf("") + } + + switch getResult.CopyStatus { + case Aborted: + return fmt.Errorf("Copy was aborted: %s", getResult.CopyStatusDescription) + + case Failed: + return fmt.Errorf("Copy failed: %s", getResult.CopyStatusDescription) + + case Success: + return nil + + case Pending: + time.Sleep(pollingInterval) + continue + } + } + + return fmt.Errorf("Unexpected error waiting for the copy to complete") +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go new file mode 100644 index 000000000000..c1c642d7d781 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go @@ -0,0 +1,105 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type DeleteInput struct { + // Should any Snapshots for this Blob also be deleted? + // If the Blob has Snapshots and this is set to False a 409 Conflict will be returned + DeleteSnapshots bool + + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string +} + +// Delete marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection. +func (client Client) Delete(ctx context.Context, accountName, containerName, blobName string, input DeleteInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "Delete", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "Delete", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "Delete", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "Delete", "`blobName` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName, containerName, blobName string, input DeleteInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + if input.DeleteSnapshots { + headers["x-ms-delete-snapshots"] = "include" + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go new file mode 100644 index 000000000000..18c3d4cffe3f --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go @@ -0,0 +1,108 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type DeleteSnapshotInput struct { + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string + + // The DateTime of the Snapshot which should be marked for Deletion + SnapshotDateTime string +} + +// DeleteSnapshot marks a single Snapshot of a Blob for Deletion based on it's DateTime, which will be deleted during the next Garbage Collection cycle. +func (client Client) DeleteSnapshot(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`blobName` cannot be an empty string.") + } + if input.SnapshotDateTime == "" { + return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`input.SnapshotDateTime` cannot be an empty string.") + } + + req, err := client.DeleteSnapshotPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshot", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSnapshotSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshot", resp, "Failure sending request") + return + } + + result, err = client.DeleteSnapshotResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshot", resp, "Failure responding to request") + return + } + + return +} + +// DeleteSnapshotPreparer prepares the DeleteSnapshot request. +func (client Client) DeleteSnapshotPreparer(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "snapshot": autorest.Encode("query", input.SnapshotDateTime), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSnapshotSender sends the DeleteSnapshot request. The method will close the +// http.Response Body if it receives an error. +func (client Client) DeleteSnapshotSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteSnapshotResponder handles the response to the DeleteSnapshot request. The method always +// closes the http.Response Body. +func (client Client) DeleteSnapshotResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go new file mode 100644 index 000000000000..e7e2b664d74d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go @@ -0,0 +1,99 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type DeleteSnapshotsInput struct { + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string +} + +// DeleteSnapshots marks all Snapshots of a Blob for Deletion, which will be deleted during the next Garbage Collection Cycle. +func (client Client) DeleteSnapshots(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotsInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`blobName` cannot be an empty string.") + } + + req, err := client.DeleteSnapshotsPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshots", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSnapshotsSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshots", resp, "Failure sending request") + return + } + + result, err = client.DeleteSnapshotsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshots", resp, "Failure responding to request") + return + } + + return +} + +// DeleteSnapshotsPreparer prepares the DeleteSnapshots request. +func (client Client) DeleteSnapshotsPreparer(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotsInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + // only delete the snapshots but leave the blob as-is + "x-ms-delete-snapshots": "only", + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSnapshotsSender sends the DeleteSnapshots request. The method will close the +// http.Response Body if it receives an error. +func (client Client) DeleteSnapshotsSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteSnapshotsResponder handles the response to the DeleteSnapshots request. The method always +// closes the http.Response Body. +func (client Client) DeleteSnapshotsResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go new file mode 100644 index 000000000000..7e0d6ee9fbd5 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go @@ -0,0 +1,116 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetInput struct { + LeaseID *string + StartByte *int64 + EndByte *int64 +} + +type GetResult struct { + autorest.Response + + Contents []byte +} + +// Get reads or downloads a blob from the system, including its metadata and properties. +func (client Client) Get(ctx context.Context, accountName, containerName, blobName string, input GetInput) (result GetResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "Get", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "Get", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "Get", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "Get", "`blobName` cannot be an empty string.") + } + if input.LeaseID != nil && *input.LeaseID == "" { + return result, validation.NewError("blobs.Client", "Get", "`input.LeaseID` should either be specified or nil, not an empty string.") + } + if (input.StartByte != nil && input.EndByte == nil) || input.StartByte == nil && input.EndByte != nil { + return result, validation.NewError("blobs.Client", "Get", "`input.StartByte` and `input.EndByte` must both be specified, or both be nil.") + } + + req, err := client.GetPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Get", resp, "Failure responding to request") + return + } + + return +} + +// GetPreparer prepares the Get request. +func (client Client) GetPreparer(ctx context.Context, accountName, containerName, blobName string, input GetInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.StartByte != nil && input.EndByte != nil { + headers["x-ms-range"] = fmt.Sprintf("bytes=%d-%d", *input.StartByte, *input.EndByte) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) GetSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client Client) GetResponder(resp *http.Response) (result GetResult, err error) { + if resp != nil && int(resp.ContentLength) > 0 { + result.Contents = make([]byte, resp.ContentLength) + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusPartialContent), + autorest.ByUnmarshallingBytes(&result.Contents), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go new file mode 100644 index 000000000000..9f8120c6c8c3 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go @@ -0,0 +1,140 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strconv" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetBlockListInput struct { + BlockListType BlockListType + LeaseID *string +} + +type GetBlockListResult struct { + autorest.Response + + // The size of the blob in bytes + ContentLength *int64 + + // The Content Type of the blob + ContentType string + + // The ETag associated with this blob + ETag string + + // A list of blocks which have been committed + CommittedBlocks CommittedBlocks `xml:"CommittedBlocks,omitempty"` + + // A list of blocks which have not yet been committed + UncommittedBlocks UncommittedBlocks `xml:"UncommittedBlocks,omitempty"` +} + +// GetBlockList retrieves the list of blocks that have been uploaded as part of a block blob. +func (client Client) GetBlockList(ctx context.Context, accountName, containerName, blobName string, input GetBlockListInput) (result GetBlockListResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "GetBlockList", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "GetBlockList", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "GetBlockList", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "GetBlockList", "`blobName` cannot be an empty string.") + } + + req, err := client.GetBlockListPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetBlockList", nil, "Failure preparing request") + return + } + + resp, err := client.GetBlockListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "GetBlockList", resp, "Failure sending request") + return + } + + result, err = client.GetBlockListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetBlockList", resp, "Failure responding to request") + return + } + + return +} + +// GetBlockListPreparer prepares the GetBlockList request. +func (client Client) GetBlockListPreparer(ctx context.Context, accountName, containerName, blobName string, input GetBlockListInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "blocklisttype": autorest.Encode("query", string(input.BlockListType)), + "comp": autorest.Encode("query", "blocklist"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetBlockListSender sends the GetBlockList request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetBlockListSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetBlockListResponder handles the response to the GetBlockList request. The method always +// closes the http.Response Body. +func (client Client) GetBlockListResponder(resp *http.Response) (result GetBlockListResult, err error) { + if resp != nil && resp.Header != nil { + result.ContentType = resp.Header.Get("Content-Type") + result.ETag = resp.Header.Get("ETag") + + if v := resp.Header.Get("x-ms-blob-content-length"); v != "" { + i, innerErr := strconv.Atoi(v) + if innerErr != nil { + err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) + return + } + + i64 := int64(i) + result.ContentLength = &i64 + } + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go new file mode 100644 index 000000000000..37abf631a28a --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go @@ -0,0 +1,152 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strconv" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetPageRangesInput struct { + LeaseID *string + + StartByte *int64 + EndByte *int64 +} + +type GetPageRangesResult struct { + autorest.Response + + // The size of the blob in bytes + ContentLength *int64 + + // The Content Type of the blob + ContentType string + + // The ETag associated with this blob + ETag string + + PageRanges []PageRange `xml:"PageRange"` +} + +type PageRange struct { + // The start byte offset for this range, inclusive + Start int64 `xml:"Start"` + + // The end byte offset for this range, inclusive + End int64 `xml:"End"` +} + +// GetPageRanges returns the list of valid page ranges for a page blob or snapshot of a page blob. +func (client Client) GetPageRanges(ctx context.Context, accountName, containerName, blobName string, input GetPageRangesInput) (result GetPageRangesResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "GetPageRanges", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "GetPageRanges", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "GetPageRanges", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "GetPageRanges", "`blobName` cannot be an empty string.") + } + if (input.StartByte != nil && input.EndByte == nil) || input.StartByte == nil && input.EndByte != nil { + return result, validation.NewError("blobs.Client", "GetPageRanges", "`input.StartByte` and `input.EndByte` must both be specified, or both be nil.") + } + + req, err := client.GetPageRangesPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetPageRanges", nil, "Failure preparing request") + return + } + + resp, err := client.GetPageRangesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "GetPageRanges", resp, "Failure sending request") + return + } + + result, err = client.GetPageRangesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetPageRanges", resp, "Failure responding to request") + return + } + + return +} + +// GetPageRangesPreparer prepares the GetPageRanges request. +func (client Client) GetPageRangesPreparer(ctx context.Context, accountName, containerName, blobName string, input GetPageRangesInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "pagelist"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + if input.StartByte != nil && input.EndByte != nil { + headers["x-ms-range"] = fmt.Sprintf("bytes=%d-%d", *input.StartByte, *input.EndByte) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetPageRangesSender sends the GetPageRanges request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetPageRangesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetPageRangesResponder handles the response to the GetPageRanges request. The method always +// closes the http.Response Body. +func (client Client) GetPageRangesResponder(resp *http.Response) (result GetPageRangesResult, err error) { + if resp != nil && resp.Header != nil { + result.ContentType = resp.Header.Get("Content-Type") + result.ETag = resp.Header.Get("ETag") + + if v := resp.Header.Get("x-ms-blob-content-length"); v != "" { + i, innerErr := strconv.Atoi(v) + if innerErr != nil { + err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) + return + } + + i64 := int64(i) + result.ContentLength = &i64 + } + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go new file mode 100644 index 000000000000..7fb7e6b55489 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go @@ -0,0 +1,120 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type IncrementalCopyBlobInput struct { + CopySource string + IfModifiedSince *string + IfUnmodifiedSince *string + IfMatch *string + IfNoneMatch *string +} + +// IncrementalCopyBlob copies a snapshot of the source page blob to a destination page blob. +// The snapshot is copied such that only the differential changes between the previously copied +// snapshot are transferred to the destination. +// The copied snapshots are complete copies of the original snapshot and can be read or copied from as usual. +func (client Client) IncrementalCopyBlob(ctx context.Context, accountName, containerName, blobName string, input IncrementalCopyBlobInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`blobName` cannot be an empty string.") + } + if input.CopySource == "" { + return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`input.CopySource` cannot be an empty string.") + } + + req, err := client.IncrementalCopyBlobPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "IncrementalCopyBlob", nil, "Failure preparing request") + return + } + + resp, err := client.IncrementalCopyBlobSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "IncrementalCopyBlob", resp, "Failure sending request") + return + } + + result, err = client.IncrementalCopyBlobResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "IncrementalCopyBlob", resp, "Failure responding to request") + return + } + + return +} + +// IncrementalCopyBlobPreparer prepares the IncrementalCopyBlob request. +func (client Client) IncrementalCopyBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input IncrementalCopyBlobInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "incrementalcopy"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-copy-source": input.CopySource, + } + + if input.IfModifiedSince != nil { + headers["If-Modified-Since"] = *input.IfModifiedSince + } + if input.IfUnmodifiedSince != nil { + headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince + } + if input.IfMatch != nil { + headers["If-Match"] = *input.IfMatch + } + if input.IfNoneMatch != nil { + headers["If-None-Match"] = *input.IfNoneMatch + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// IncrementalCopyBlobSender sends the IncrementalCopyBlob request. The method will close the +// http.Response Body if it receives an error. +func (client Client) IncrementalCopyBlobSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// IncrementalCopyBlobResponder handles the response to the IncrementalCopyBlob request. The method always +// closes the http.Response Body. +func (client Client) IncrementalCopyBlobResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go new file mode 100644 index 000000000000..c4b49d73ae71 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go @@ -0,0 +1,135 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type AcquireLeaseInput struct { + // The ID of the existing Lease, if leased + LeaseID *string + + // Specifies the duration of the lease, in seconds, or negative one (-1) for a lease that never expires. + // A non-infinite lease can be between 15 and 60 seconds + LeaseDuration int + + // The Proposed new ID for the Lease + ProposedLeaseID *string +} + +type AcquireLeaseResult struct { + autorest.Response + + LeaseID string +} + +// AcquireLease establishes and manages a lock on a blob for write and delete operations. +func (client Client) AcquireLease(ctx context.Context, accountName, containerName, blobName string, input AcquireLeaseInput) (result AcquireLeaseResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "AcquireLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "AcquireLease", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "AcquireLease", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "AcquireLease", "`blobName` cannot be an empty string.") + } + if input.LeaseID != nil && *input.LeaseID == "" { + return result, validation.NewError("blobs.Client", "AcquireLease", "`input.LeaseID` cannot be an empty string, if specified.") + } + if input.ProposedLeaseID != nil && *input.ProposedLeaseID == "" { + return result, validation.NewError("blobs.Client", "AcquireLease", "`input.ProposedLeaseID` cannot be an empty string, if specified.") + } + // An infinite lease duration is -1 seconds. A non-infinite lease can be between 15 and 60 seconds + if input.LeaseDuration != -1 && (input.LeaseDuration <= 15 || input.LeaseDuration >= 60) { + return result, validation.NewError("blobs.Client", "AcquireLease", "`input.LeaseDuration` must be -1 (infinite), or between 15 and 60 seconds.") + } + + req, err := client.AcquireLeasePreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "AcquireLease", nil, "Failure preparing request") + return + } + + resp, err := client.AcquireLeaseSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "AcquireLease", resp, "Failure sending request") + return + } + + result, err = client.AcquireLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "AcquireLease", resp, "Failure responding to request") + return + } + + return +} + +// AcquireLeasePreparer prepares the AcquireLease request. +func (client Client) AcquireLeasePreparer(ctx context.Context, accountName, containerName, blobName string, input AcquireLeaseInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "acquire", + "x-ms-lease-duration": input.LeaseDuration, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + if input.ProposedLeaseID != nil { + headers["x-ms-proposed-lease-id"] = *input.ProposedLeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// AcquireLeaseSender sends the AcquireLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) AcquireLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// AcquireLeaseResponder handles the response to the AcquireLease request. The method always +// closes the http.Response Body. +func (client Client) AcquireLeaseResponder(resp *http.Response) (result AcquireLeaseResult, err error) { + if resp != nil && resp.Header != nil { + result.LeaseID = resp.Header.Get("x-ms-lease-id") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go new file mode 100644 index 000000000000..d5642045d20d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go @@ -0,0 +1,124 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type BreakLeaseInput struct { + // For a break operation, proposed duration the lease should continue + // before it is broken, in seconds, between 0 and 60. + // This break period is only used if it is shorter than the time remaining on the lease. + // If longer, the time remaining on the lease is used. + // A new lease will not be available before the break period has expired, + // but the lease may be held for longer than the break period. + // If this header does not appear with a break operation, a fixed-duration lease breaks + // after the remaining lease period elapses, and an infinite lease breaks immediately. + BreakPeriod *int + + LeaseID string +} + +type BreakLeaseResponse struct { + autorest.Response + + // Approximate time remaining in the lease period, in seconds. + // If the break is immediate, 0 is returned. + LeaseTime int +} + +// BreakLease breaks an existing lock on a blob using the LeaseID. +func (client Client) BreakLease(ctx context.Context, accountName, containerName, blobName string, input BreakLeaseInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "BreakLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "BreakLease", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "BreakLease", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "BreakLease", "`blobName` cannot be an empty string.") + } + if input.LeaseID == "" { + return result, validation.NewError("blobs.Client", "BreakLease", "`input.LeaseID` cannot be an empty string.") + } + + req, err := client.BreakLeasePreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "BreakLease", nil, "Failure preparing request") + return + } + + resp, err := client.BreakLeaseSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "BreakLease", resp, "Failure sending request") + return + } + + result, err = client.BreakLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "BreakLease", resp, "Failure responding to request") + return + } + + return +} + +// BreakLeasePreparer prepares the BreakLease request. +func (client Client) BreakLeasePreparer(ctx context.Context, accountName, containerName, blobName string, input BreakLeaseInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "break", + "x-ms-lease-id": input.LeaseID, + } + + if input.BreakPeriod != nil { + headers["x-ms-lease-break-period"] = *input.BreakPeriod + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// BreakLeaseSender sends the BreakLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) BreakLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// BreakLeaseResponder handles the response to the BreakLease request. The method always +// closes the http.Response Body. +func (client Client) BreakLeaseResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go new file mode 100644 index 000000000000..c57f9db875b0 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go @@ -0,0 +1,117 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type ChangeLeaseInput struct { + ExistingLeaseID string + ProposedLeaseID string +} + +type ChangeLeaseResponse struct { + autorest.Response + + LeaseID string +} + +// ChangeLease changes an existing lock on a blob for another lock. +func (client Client) ChangeLease(ctx context.Context, accountName, containerName, blobName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "ChangeLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "ChangeLease", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "ChangeLease", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "ChangeLease", "`blobName` cannot be an empty string.") + } + if input.ExistingLeaseID == "" { + return result, validation.NewError("blobs.Client", "ChangeLease", "`input.ExistingLeaseID` cannot be an empty string.") + } + if input.ProposedLeaseID == "" { + return result, validation.NewError("blobs.Client", "ChangeLease", "`input.ProposedLeaseID` cannot be an empty string.") + } + + req, err := client.ChangeLeasePreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "ChangeLease", nil, "Failure preparing request") + return + } + + resp, err := client.ChangeLeaseSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "ChangeLease", resp, "Failure sending request") + return + } + + result, err = client.ChangeLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "ChangeLease", resp, "Failure responding to request") + return + } + + return +} + +// ChangeLeasePreparer prepares the ChangeLease request. +func (client Client) ChangeLeasePreparer(ctx context.Context, accountName, containerName, blobName string, input ChangeLeaseInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "change", + "x-ms-lease-id": input.ExistingLeaseID, + "x-ms-proposed-lease-id": input.ProposedLeaseID, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ChangeLeaseSender sends the ChangeLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ChangeLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ChangeLeaseResponder handles the response to the ChangeLease request. The method always +// closes the http.Response Body. +func (client Client) ChangeLeaseResponder(resp *http.Response) (result ChangeLeaseResponse, err error) { + if resp != nil && resp.Header != nil { + result.LeaseID = resp.Header.Get("x-ms-lease-id") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go new file mode 100644 index 000000000000..0226cdf37552 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go @@ -0,0 +1,98 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// ReleaseLease releases a lock based on the Lease ID. +func (client Client) ReleaseLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "ReleaseLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "ReleaseLease", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "ReleaseLease", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "ReleaseLease", "`blobName` cannot be an empty string.") + } + if leaseID == "" { + return result, validation.NewError("blobs.Client", "ReleaseLease", "`leaseID` cannot be an empty string.") + } + + req, err := client.ReleaseLeasePreparer(ctx, accountName, containerName, blobName, leaseID) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "ReleaseLease", nil, "Failure preparing request") + return + } + + resp, err := client.ReleaseLeaseSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "ReleaseLease", resp, "Failure sending request") + return + } + + result, err = client.ReleaseLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "ReleaseLease", resp, "Failure responding to request") + return + } + + return +} + +// ReleaseLeasePreparer prepares the ReleaseLease request. +func (client Client) ReleaseLeasePreparer(ctx context.Context, accountName, containerName, blobName, leaseID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "release", + "x-ms-lease-id": leaseID, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ReleaseLeaseSender sends the ReleaseLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ReleaseLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ReleaseLeaseResponder handles the response to the ReleaseLease request. The method always +// closes the http.Response Body. +func (client Client) ReleaseLeaseResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go new file mode 100644 index 000000000000..69c495bd9898 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go @@ -0,0 +1,97 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +func (client Client) RenewLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "RenewLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "RenewLease", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "RenewLease", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "RenewLease", "`blobName` cannot be an empty string.") + } + if leaseID == "" { + return result, validation.NewError("blobs.Client", "RenewLease", "`leaseID` cannot be an empty string.") + } + + req, err := client.RenewLeasePreparer(ctx, accountName, containerName, blobName, leaseID) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "RenewLease", nil, "Failure preparing request") + return + } + + resp, err := client.RenewLeaseSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "RenewLease", resp, "Failure sending request") + return + } + + result, err = client.RenewLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "RenewLease", resp, "Failure responding to request") + return + } + + return +} + +// RenewLeasePreparer prepares the RenewLease request. +func (client Client) RenewLeasePreparer(ctx context.Context, accountName, containerName, blobName, leaseID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "renew", + "x-ms-lease-id": leaseID, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// RenewLeaseSender sends the RenewLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) RenewLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// RenewLeaseResponder handles the response to the RenewLease request. The method always +// closes the http.Response Body. +func (client Client) RenewLeaseResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go new file mode 100644 index 000000000000..ec69152a5f98 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go @@ -0,0 +1,113 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type SetMetaDataInput struct { + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string + + // Any metadata which should be added to this blob + MetaData map[string]string +} + +// SetMetaData marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection. +func (client Client) SetMetaData(ctx context.Context, accountName, containerName, blobName string, input SetMetaDataInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "GetProperties", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "GetProperties", "`blobName` cannot be an empty string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("blobs.Client", "GetProperties", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.SetMetaDataPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "SetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.SetMetaDataSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "SetMetaData", resp, "Failure sending request") + return + } + + result, err = client.SetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "SetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// SetMetaDataPreparer prepares the SetMetaData request. +func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, containerName, blobName string, input SetMetaDataInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetMetaDataSender sends the SetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetMetaDataResponder handles the response to the SetMetaData request. The method always +// closes the http.Response Body. +func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go new file mode 100644 index 000000000000..d7d83aade8c0 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go @@ -0,0 +1,82 @@ +package blobs + +type AccessTier string + +var ( + Archive AccessTier = "Archive" + Cool AccessTier = "Cool" + Hot AccessTier = "Hot" +) + +type ArchiveStatus string + +var ( + None ArchiveStatus = "" + RehydratePendingToCool ArchiveStatus = "rehydrate-pending-to-cool" + RehydratePendingToHot ArchiveStatus = "rehydrate-pending-to-hot" +) + +type BlockListType string + +var ( + All BlockListType = "all" + Committed BlockListType = "committed" + Uncommitted BlockListType = "uncommitted" +) + +type Block struct { + // The base64-encoded Block ID + Name string `xml:"Name"` + + // The size of the Block in Bytes + Size int64 `xml:"Size"` +} + +type BlobType string + +var ( + AppendBlob BlobType = "AppendBlob" + BlockBlob BlobType = "BlockBlob" + PageBlob BlobType = "PageBlob" +) + +type CommittedBlocks struct { + Blocks []Block `xml:"Block"` +} + +type CopyStatus string + +var ( + Aborted CopyStatus = "aborted" + Failed CopyStatus = "failed" + Pending CopyStatus = "pending" + Success CopyStatus = "success" +) + +type LeaseDuration string + +var ( + Fixed LeaseDuration = "fixed" + Infinite LeaseDuration = "infinite" +) + +type LeaseState string + +var ( + Available LeaseState = "available" + Breaking LeaseState = "breaking" + Broken LeaseState = "broken" + Expired LeaseState = "expired" + Leased LeaseState = "leased" +) + +type LeaseStatus string + +var ( + Locked LeaseStatus = "locked" + Unlocked LeaseStatus = "unlocked" +) + +type UncommittedBlocks struct { + Blocks []Block `xml:"Block"` +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go new file mode 100644 index 000000000000..5640687d6d92 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go @@ -0,0 +1,310 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strconv" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetPropertiesInput struct { + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string +} + +type GetPropertiesResult struct { + autorest.Response + + // The tier of page blob on a premium storage account or tier of block blob on blob storage or general purpose v2 account. + AccessTier AccessTier + + // This gives the last time tier was changed on the object. + // This header is returned only if tier on block blob was ever set. + // The date format follows RFC 1123 + AccessTierChangeTime string + + // For page blobs on a premium storage account only. + // If the access tier is not explicitly set on the blob, the tier is inferred based on its content length + // and this header will be returned with true value. + // For block blobs on Blob Storage or general purpose v2 account, if the blob does not have the access tier + // set then we infer the tier from the storage account properties. This header is set only if the block blob + // tier is inferred + AccessTierInferred bool + + // For blob storage or general purpose v2 account. + // If the blob is being rehydrated and is not complete then this header is returned indicating + // that rehydrate is pending and also tells the destination tier + ArchiveStatus ArchiveStatus + + // The number of committed blocks present in the blob. + // This header is returned only for append blobs. + BlobCommittedBlockCount string + + // The current sequence number for a page blob. + // This header is not returned for block blobs or append blobs. + // This header is not returned for block blobs. + BlobSequenceNumber string + + // The blob type. + BlobType BlobType + + // If the Cache-Control request header has previously been set for the blob, that value is returned in this header. + CacheControl string + + // The Content-Disposition response header field conveys additional information about how to process + // the response payload, and also can be used to attach additional metadata. + // For example, if set to attachment, it indicates that the user-agent should not display the response, + // but instead show a Save As dialog. + ContentDisposition string + + // If the Content-Encoding request header has previously been set for the blob, + // that value is returned in this header. + ContentEncoding string + + // If the Content-Language request header has previously been set for the blob, + // that value is returned in this header. + ContentLanguage string + + // The size of the blob in bytes. + // For a page blob, this header returns the value of the x-ms-blob-content-length header stored with the blob. + ContentLength int64 + + // The content type specified for the blob. + // If no content type was specified, the default content type is `application/octet-stream`. + ContentType string + + // If the Content-MD5 header has been set for the blob, this response header is returned so that + // the client can check for message content integrity. + ContentMD5 string + + // Conclusion time of the last attempted Copy Blob operation where this blob was the destination blob. + // This value can specify the time of a completed, aborted, or failed copy attempt. + // This header does not appear if a copy is pending, if this blob has never been the + // destination in a Copy Blob operation, or if this blob has been modified after a concluded Copy Blob + // operation using Set Blob Properties, Put Blob, or Put Block List. + CopyCompletionTime string + + // Included if the blob is incremental copy blob or incremental copy snapshot, if x-ms-copy-status is success. + // Snapshot time of the last successful incremental copy snapshot for this blob + CopyDestinationSnapshot string + + // String identifier for the last attempted Copy Blob operation where this blob was the destination blob. + // This header does not appear if this blob has never been the destination in a Copy Blob operation, + // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, + // Put Blob, or Put Block List. + CopyID string + + // Contains the number of bytes copied and the total bytes in the source in the last attempted + // Copy Blob operation where this blob was the destination blob. + // Can show between 0 and Content-Length bytes copied. + // This header does not appear if this blob has never been the destination in a Copy Blob operation, + // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, + // Put Blob, or Put Block List. + CopyProgress string + + // URL up to 2 KB in length that specifies the source blob used in the last attempted Copy Blob operation + // where this blob was the destination blob. + // This header does not appear if this blob has never been the destination in a Copy Blob operation, + // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, + // Put Blob, or Put Block List + CopySource string + + // State of the copy operation identified by x-ms-copy-id, with these values: + // - success: Copy completed successfully. + // - pending: Copy is in progress. + // Check x-ms-copy-status-description if intermittent, non-fatal errors + // impede copy progress but don’t cause failure. + // - aborted: Copy was ended by Abort Copy Blob. + // - failed: Copy failed. See x-ms- copy-status-description for failure details. + // This header does not appear if this blob has never been the destination in a Copy Blob operation, + // or if this blob has been modified after a completed Copy Blob operation using Set Blob Properties, + // Put Blob, or Put Block List. + CopyStatus CopyStatus + + // Describes cause of fatal or non-fatal copy operation failure. + // This header does not appear if this blob has never been the destination in a Copy Blob operation, + // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, + // Put Blob, or Put Block List. + CopyStatusDescription string + + // The date/time at which the blob was created. The date format follows RFC 1123 + CreationTime string + + // The ETag contains a value that you can use to perform operations conditionally + ETag string + + // Included if the blob is incremental copy blob. + IncrementalCopy bool + + // The date/time that the blob was last modified. The date format follows RFC 1123. + LastModified string + + // When a blob is leased, specifies whether the lease is of infinite or fixed duration + LeaseDuration LeaseDuration + + // The lease state of the blob + LeaseState LeaseState + + LeaseStatus LeaseStatus + + // A set of name-value pairs that correspond to the user-defined metadata associated with this blob + MetaData map[string]string + + // Is the Storage Account encrypted using server-side encryption? This should always return true + ServerEncrypted bool +} + +// GetProperties returns all user-defined metadata, standard HTTP properties, and system properties for the blob +func (client Client) GetProperties(ctx context.Context, accountName, containerName, blobName string, input GetPropertiesInput) (result GetPropertiesResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "GetProperties", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "GetProperties", "`blobName` cannot be an empty string.") + } + + req, err := client.GetPropertiesPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetPropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "GetProperties", resp, "Failure sending request") + return + } + + result, err = client.GetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetProperties", resp, "Failure responding to request") + return + } + + return +} + +// GetPropertiesPreparer prepares the GetProperties request. +func (client Client) GetPropertiesPreparer(ctx context.Context, accountName, containerName, blobName string, input GetPropertiesInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsHead(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetPropertiesResponder handles the response to the GetProperties request. The method always +// closes the http.Response Body. +func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResult, err error) { + if resp != nil && resp.Header != nil { + result.AccessTier = AccessTier(resp.Header.Get("x-ms-access-tier")) + result.AccessTierChangeTime = resp.Header.Get(" x-ms-access-tier-change-time") + result.ArchiveStatus = ArchiveStatus(resp.Header.Get(" x-ms-archive-status")) + result.BlobCommittedBlockCount = resp.Header.Get("x-ms-blob-committed-block-count") + result.BlobSequenceNumber = resp.Header.Get("x-ms-blob-sequence-number") + result.BlobType = BlobType(resp.Header.Get("x-ms-blob-type")) + result.CacheControl = resp.Header.Get("Cache-Control") + result.ContentDisposition = resp.Header.Get("Content-Disposition") + result.ContentEncoding = resp.Header.Get("Content-Encoding") + result.ContentLanguage = resp.Header.Get("Content-Language") + result.ContentMD5 = resp.Header.Get("Content-MD5") + result.ContentType = resp.Header.Get("Content-Type") + result.CopyCompletionTime = resp.Header.Get("x-ms-copy-completion-time") + result.CopyDestinationSnapshot = resp.Header.Get("x-ms-copy-destination-snapshot") + result.CopyID = resp.Header.Get("x-ms-copy-id") + result.CopyProgress = resp.Header.Get("x-ms-copy-progress") + result.CopySource = resp.Header.Get("x-ms-copy-source") + result.CopyStatus = CopyStatus(resp.Header.Get("x-ms-copy-status")) + result.CopyStatusDescription = resp.Header.Get("x-ms-copy-status-description") + result.CreationTime = resp.Header.Get("x-ms-creation-time") + result.ETag = resp.Header.Get("Etag") + result.LastModified = resp.Header.Get("Last-Modified") + result.LeaseDuration = LeaseDuration(resp.Header.Get("x-ms-lease-duration")) + result.LeaseState = LeaseState(resp.Header.Get("x-ms-lease-state")) + result.LeaseStatus = LeaseStatus(resp.Header.Get("x-ms-lease-status")) + result.MetaData = metadata.ParseFromHeaders(resp.Header) + + if v := resp.Header.Get("x-ms-access-tier-inferred"); v != "" { + b, innerErr := strconv.ParseBool(v) + if innerErr != nil { + err = fmt.Errorf("Error parsing %q as a bool: %s", v, innerErr) + return + } + + result.AccessTierInferred = b + } + + if v := resp.Header.Get("Content-Length"); v != "" { + i, innerErr := strconv.Atoi(v) + if innerErr != nil { + err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) + } + + result.ContentLength = int64(i) + } + + if v := resp.Header.Get("x-ms-incremental-copy"); v != "" { + b, innerErr := strconv.ParseBool(v) + if innerErr != nil { + err = fmt.Errorf("Error parsing %q as a bool: %s", v, innerErr) + return + } + + result.IncrementalCopy = b + } + + if v := resp.Header.Get("x-ms-server-encrypted"); v != "" { + b, innerErr := strconv.ParseBool(v) + if innerErr != nil { + err = fmt.Errorf("Error parsing %q as a bool: %s", v, innerErr) + return + } + + result.IncrementalCopy = b + } + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go new file mode 100644 index 000000000000..a8c0ed8cba95 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go @@ -0,0 +1,156 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type SetPropertiesInput struct { + CacheControl *string + ContentType *string + ContentMD5 *string + ContentEncoding *string + ContentLanguage *string + LeaseID *string + ContentDisposition *string + ContentLength *int64 + SequenceNumberAction *SequenceNumberAction + BlobSequenceNumber *string +} + +type SetPropertiesResult struct { + autorest.Response + + BlobSequenceNumber string + Etag string +} + +// SetProperties sets system properties on the blob. +func (client Client) SetProperties(ctx context.Context, accountName, containerName, blobName string, input SetPropertiesInput) (result SetPropertiesResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "SetProperties", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "SetProperties", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "SetProperties", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "SetProperties", "`blobName` cannot be an empty string.") + } + + req, err := client.SetPropertiesPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "SetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.SetPropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "SetProperties", resp, "Failure sending request") + return + } + + result, err = client.SetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "SetProperties", resp, "Failure responding to request") + return + } + + return +} + +type SequenceNumberAction string + +var ( + Increment SequenceNumberAction = "increment" + Max SequenceNumberAction = "max" + Update SequenceNumberAction = "update" +) + +// SetPropertiesPreparer prepares the SetProperties request. +func (client Client) SetPropertiesPreparer(ctx context.Context, accountName, containerName, blobName string, input SetPropertiesInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "properties"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.CacheControl != nil { + headers["x-ms-blob-cache-control"] = *input.CacheControl + } + if input.ContentDisposition != nil { + headers["x-ms-blob-content-disposition"] = *input.ContentDisposition + } + if input.ContentEncoding != nil { + headers["x-ms-blob-content-encoding"] = *input.ContentEncoding + } + if input.ContentLanguage != nil { + headers["x-ms-blob-content-language"] = *input.ContentLanguage + } + if input.ContentMD5 != nil { + headers["x-ms-blob-content-md5"] = *input.ContentMD5 + } + if input.ContentType != nil { + headers["x-ms-blob-content-type"] = *input.ContentType + } + if input.ContentLength != nil { + headers["x-ms-blob-content-length"] = *input.ContentLength + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + if input.SequenceNumberAction != nil { + headers["x-ms-sequence-number-action"] = string(*input.SequenceNumberAction) + } + if input.BlobSequenceNumber != nil { + headers["x-ms-blob-sequence-number"] = *input.BlobSequenceNumber + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetPropertiesSender sends the SetProperties request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetPropertiesResponder handles the response to the SetProperties request. The method always +// closes the http.Response Body. +func (client Client) SetPropertiesResponder(resp *http.Response) (result SetPropertiesResult, err error) { + if resp != nil && resp.Header != nil { + result.BlobSequenceNumber = resp.Header.Get("x-ms-blob-sequence-number") + result.Etag = resp.Header.Get("Etag") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go new file mode 100644 index 000000000000..ef2c5025d606 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go @@ -0,0 +1,134 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type PutAppendBlobInput struct { + CacheControl *string + ContentDisposition *string + ContentEncoding *string + ContentLanguage *string + ContentMD5 *string + ContentType *string + LeaseID *string + MetaData map[string]string +} + +// PutAppendBlob is a wrapper around the Put API call (with a stricter input object) +// which creates a new append blob, or updates the content of an existing blob. +func (client Client) PutAppendBlob(ctx context.Context, accountName, containerName, blobName string, input PutAppendBlobInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutAppendBlob", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutAppendBlob", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutAppendBlob", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutAppendBlob", "`blobName` cannot be an empty string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("blobs.Client", "PutAppendBlob", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.PutAppendBlobPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutAppendBlob", nil, "Failure preparing request") + return + } + + resp, err := client.PutAppendBlobSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutAppendBlob", resp, "Failure sending request") + return + } + + result, err = client.PutAppendBlobResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutAppendBlob", resp, "Failure responding to request") + return + } + + return +} + +// PutAppendBlobPreparer prepares the PutAppendBlob request. +func (client Client) PutAppendBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input PutAppendBlobInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-blob-type": string(AppendBlob), + "x-ms-version": APIVersion, + + // For a page blob or an append blob, the value of this header must be set to zero, + // as Put Blob is used only to initialize the blob + "Content-Length": 0, + } + + if input.CacheControl != nil { + headers["x-ms-blob-cache-control"] = *input.CacheControl + } + if input.ContentDisposition != nil { + headers["x-ms-blob-content-disposition"] = *input.ContentDisposition + } + if input.ContentEncoding != nil { + headers["x-ms-blob-content-encoding"] = *input.ContentEncoding + } + if input.ContentLanguage != nil { + headers["x-ms-blob-content-language"] = *input.ContentLanguage + } + if input.ContentMD5 != nil { + headers["x-ms-blob-content-md5"] = *input.ContentMD5 + } + if input.ContentType != nil { + headers["x-ms-blob-content-type"] = *input.ContentType + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutAppendBlobSender sends the PutAppendBlob request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutAppendBlobSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutAppendBlobResponder handles the response to the PutAppendBlob request. The method always +// closes the http.Response Body. +func (client Client) PutAppendBlobResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go new file mode 100644 index 000000000000..6d41bda13b55 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go @@ -0,0 +1,126 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type PutBlockInput struct { + BlockID string + Content []byte + ContentMD5 *string + LeaseID *string +} + +type PutBlockResult struct { + autorest.Response + + ContentMD5 string +} + +// PutBlock creates a new block to be committed as part of a blob. +func (client Client) PutBlock(ctx context.Context, accountName, containerName, blobName string, input PutBlockInput) (result PutBlockResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutBlock", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutBlock", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutBlock", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutBlock", "`blobName` cannot be an empty string.") + } + if input.BlockID == "" { + return result, validation.NewError("blobs.Client", "PutBlock", "`input.BlockID` cannot be an empty string.") + } + if len(input.Content) == 0 { + return result, validation.NewError("blobs.Client", "PutBlock", "`input.Content` cannot be empty.") + } + + req, err := client.PutBlockPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlock", nil, "Failure preparing request") + return + } + + resp, err := client.PutBlockSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlock", resp, "Failure sending request") + return + } + + result, err = client.PutBlockResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlock", resp, "Failure responding to request") + return + } + + return +} + +// PutBlockPreparer prepares the PutBlock request. +func (client Client) PutBlockPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "block"), + "blockid": autorest.Encode("query", input.BlockID), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "Content-Length": int(len(input.Content)), + } + + if input.ContentMD5 != nil { + headers["x-ms-blob-content-md5"] = *input.ContentMD5 + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers), + autorest.WithBytes(&input.Content)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutBlockSender sends the PutBlock request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutBlockSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutBlockResponder handles the response to the PutBlock request. The method always +// closes the http.Response Body. +func (client Client) PutBlockResponder(resp *http.Response) (result PutBlockResult, err error) { + if resp != nil && resp.Header != nil { + result.ContentMD5 = resp.Header.Get("Content-MD5") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go new file mode 100644 index 000000000000..f5c1a971b306 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go @@ -0,0 +1,144 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type PutBlockBlobInput struct { + CacheControl *string + Content *[]byte + ContentDisposition *string + ContentEncoding *string + ContentLanguage *string + ContentMD5 *string + ContentType *string + LeaseID *string + MetaData map[string]string +} + +// PutBlockBlob is a wrapper around the Put API call (with a stricter input object) +// which creates a new block append blob, or updates the content of an existing block blob. +func (client Client) PutBlockBlob(ctx context.Context, accountName, containerName, blobName string, input PutBlockBlobInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutBlockBlob", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutBlockBlob", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutBlockBlob", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutBlockBlob", "`blobName` cannot be an empty string.") + } + if input.Content != nil && len(*input.Content) == 0 { + return result, validation.NewError("blobs.Client", "PutBlockBlob", "`input.Content` must either be nil or not empty.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("blobs.Client", "PutBlockBlob", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.PutBlockBlobPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockBlob", nil, "Failure preparing request") + return + } + + resp, err := client.PutBlockBlobSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockBlob", resp, "Failure sending request") + return + } + + result, err = client.PutBlockBlobResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockBlob", resp, "Failure responding to request") + return + } + + return +} + +// PutBlockBlobPreparer prepares the PutBlockBlob request. +func (client Client) PutBlockBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockBlobInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-blob-type": string(BlockBlob), + "x-ms-version": APIVersion, + } + + if input.CacheControl != nil { + headers["x-ms-blob-cache-control"] = *input.CacheControl + } + if input.ContentDisposition != nil { + headers["x-ms-blob-content-disposition"] = *input.ContentDisposition + } + if input.ContentEncoding != nil { + headers["x-ms-blob-content-encoding"] = *input.ContentEncoding + } + if input.ContentLanguage != nil { + headers["x-ms-blob-content-language"] = *input.ContentLanguage + } + if input.ContentMD5 != nil { + headers["x-ms-blob-content-md5"] = *input.ContentMD5 + } + if input.ContentType != nil { + headers["x-ms-blob-content-type"] = *input.ContentType + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + if input.Content != nil { + headers["Content-Length"] = int(len(*input.Content)) + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + decorators := []autorest.PrepareDecorator{ + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + } + + if input.Content != nil { + decorators = append(decorators, autorest.WithBytes(input.Content)) + } + + preparer := autorest.CreatePreparer(decorators...) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutBlockBlobSender sends the PutBlockBlob request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutBlockBlobSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutBlockBlobResponder handles the response to the PutBlockBlob request. The method always +// closes the http.Response Body. +func (client Client) PutBlockBlobResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go new file mode 100644 index 000000000000..b7499498aeca --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go @@ -0,0 +1,34 @@ +package blobs + +import ( + "context" + "fmt" + "io" + "os" +) + +// PutBlockBlobFromFile is a helper method which takes a file, and automatically chunks it up, rather than having to do this yourself +func (client Client) PutBlockBlobFromFile(ctx context.Context, accountName, containerName, blobName string, file *os.File, input PutBlockBlobInput) error { + fileInfo, err := file.Stat() + if err != nil { + return fmt.Errorf("Error loading file info: %s", err) + } + + fileSize := fileInfo.Size() + bytes := make([]byte, fileSize) + + _, err = file.ReadAt(bytes, 0) + if err != nil { + if err != io.EOF { + return fmt.Errorf("Error reading bytes: %s", err) + } + } + + input.Content = &bytes + + if _, err = client.PutBlockBlob(ctx, accountName, containerName, blobName, input); err != nil { + return fmt.Errorf("Error putting bytes: %s", err) + } + + return nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go new file mode 100644 index 000000000000..f80524790be5 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go @@ -0,0 +1,157 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type BlockList struct { + CommittedBlockIDs []BlockID `xml:"Committed,omitempty"` + UncommittedBlockIDs []BlockID `xml:"Uncommitted,omitempty"` + LatestBlockIDs []BlockID `xml:"Latest,omitempty"` +} + +type BlockID struct { + Value string `xml:",chardata"` +} + +type PutBlockListInput struct { + BlockList BlockList + CacheControl *string + ContentDisposition *string + ContentEncoding *string + ContentLanguage *string + ContentMD5 *string + ContentType *string + MetaData map[string]string + LeaseID *string +} + +type PutBlockListResult struct { + autorest.Response + + ContentMD5 string + ETag string + LastModified string +} + +// PutBlockList writes a blob by specifying the list of block IDs that make up the blob. +// In order to be written as part of a blob, a block must have been successfully written +// to the server in a prior Put Block operation. +func (client Client) PutBlockList(ctx context.Context, accountName, containerName, blobName string, input PutBlockListInput) (result PutBlockListResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutBlockList", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutBlockList", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutBlockList", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutBlockList", "`blobName` cannot be an empty string.") + } + + req, err := client.PutBlockListPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockList", nil, "Failure preparing request") + return + } + + resp, err := client.PutBlockListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockList", resp, "Failure sending request") + return + } + + result, err = client.PutBlockListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockList", resp, "Failure responding to request") + return + } + + return +} + +// PutBlockListPreparer prepares the PutBlockList request. +func (client Client) PutBlockListPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockListInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "blocklist"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.CacheControl != nil { + headers["x-ms-blob-cache-control"] = *input.CacheControl + } + if input.ContentDisposition != nil { + headers["x-ms-blob-content-disposition"] = *input.ContentDisposition + } + if input.ContentEncoding != nil { + headers["x-ms-blob-content-encoding"] = *input.ContentEncoding + } + if input.ContentLanguage != nil { + headers["x-ms-blob-content-language"] = *input.ContentLanguage + } + if input.ContentMD5 != nil { + headers["x-ms-blob-content-md5"] = *input.ContentMD5 + } + if input.ContentType != nil { + headers["x-ms-blob-content-type"] = *input.ContentType + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers), + autorest.WithXML(input.BlockList)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutBlockListSender sends the PutBlockList request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutBlockListSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutBlockListResponder handles the response to the PutBlockList request. The method always +// closes the http.Response Body. +func (client Client) PutBlockListResponder(resp *http.Response) (result PutBlockListResult, err error) { + if resp != nil && resp.Header != nil { + result.ContentMD5 = resp.Header.Get("Content-MD5") + result.ETag = resp.Header.Get("ETag") + result.LastModified = resp.Header.Get("Last-Modified") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go new file mode 100644 index 000000000000..95ad974698bd --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go @@ -0,0 +1,129 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type PutBlockFromURLInput struct { + BlockID string + CopySource string + + ContentMD5 *string + LeaseID *string + Range *string +} + +type PutBlockFromURLResult struct { + autorest.Response + ContentMD5 string +} + +// PutBlockFromURL creates a new block to be committed as part of a blob where the contents are read from a URL +func (client Client) PutBlockFromURL(ctx context.Context, accountName, containerName, blobName string, input PutBlockFromURLInput) (result PutBlockFromURLResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`blobName` cannot be an empty string.") + } + if input.BlockID == "" { + return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`input.BlockID` cannot be an empty string.") + } + if input.CopySource == "" { + return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`input.CopySource` cannot be an empty string.") + } + + req, err := client.PutBlockFromURLPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockFromURL", nil, "Failure preparing request") + return + } + + resp, err := client.PutBlockFromURLSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockFromURL", resp, "Failure sending request") + return + } + + result, err = client.PutBlockFromURLResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockFromURL", resp, "Failure responding to request") + return + } + + return +} + +// PutBlockFromURLPreparer prepares the PutBlockFromURL request. +func (client Client) PutBlockFromURLPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockFromURLInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "block"), + "blockid": autorest.Encode("query", input.BlockID), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-copy-source": input.CopySource, + } + + if input.ContentMD5 != nil { + headers["x-ms-source-content-md5"] = *input.ContentMD5 + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + if input.Range != nil { + headers["x-ms-source-range"] = *input.Range + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutBlockFromURLSender sends the PutBlockFromURL request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutBlockFromURLSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutBlockFromURLResponder handles the response to the PutBlockFromURL request. The method always +// closes the http.Response Body. +func (client Client) PutBlockFromURLResponder(resp *http.Response) (result PutBlockFromURLResult, err error) { + if resp != nil && resp.Header != nil { + result.ContentMD5 = resp.Header.Get("Content-MD5") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go new file mode 100644 index 000000000000..4cfba95ae37b --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go @@ -0,0 +1,148 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type PutPageBlobInput struct { + CacheControl *string + ContentDisposition *string + ContentEncoding *string + ContentLanguage *string + ContentMD5 *string + ContentType *string + LeaseID *string + MetaData map[string]string + + BlobContentLengthBytes int64 + BlobSequenceNumber *int64 + AccessTier *AccessTier +} + +// PutPageBlob is a wrapper around the Put API call (with a stricter input object) +// which creates a new block blob, or updates the content of an existing page blob. +func (client Client) PutPageBlob(ctx context.Context, accountName, containerName, blobName string, input PutPageBlobInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutPageBlob", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutPageBlob", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutPageBlob", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutPageBlob", "`blobName` cannot be an empty string.") + } + if input.BlobContentLengthBytes == 0 || input.BlobContentLengthBytes%512 != 0 { + return result, validation.NewError("blobs.Client", "PutPageBlob", "`input.BlobContentLengthBytes` must be aligned to a 512-byte boundary.") + } + + req, err := client.PutPageBlobPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageBlob", nil, "Failure preparing request") + return + } + + resp, err := client.PutPageBlobSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageBlob", resp, "Failure sending request") + return + } + + result, err = client.PutPageBlobResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageBlob", resp, "Failure responding to request") + return + } + + return +} + +// PutPageBlobPreparer prepares the PutPageBlob request. +func (client Client) PutPageBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input PutPageBlobInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + headers := map[string]interface{}{ + "x-ms-blob-type": string(PageBlob), + "x-ms-version": APIVersion, + + // For a page blob or an page blob, the value of this header must be set to zero, + // as Put Blob is used only to initialize the blob + "Content-Length": 0, + + // This header specifies the maximum size for the page blob, up to 8 TB. + // The page blob size must be aligned to a 512-byte boundary. + "x-ms-blob-content-length": input.BlobContentLengthBytes, + } + + if input.AccessTier != nil { + headers["x-ms-access-tier"] = string(*input.AccessTier) + } + if input.BlobSequenceNumber != nil { + headers["x-ms-blob-sequence-number"] = *input.BlobSequenceNumber + } + + if input.CacheControl != nil { + headers["x-ms-blob-cache-control"] = *input.CacheControl + } + if input.ContentDisposition != nil { + headers["x-ms-blob-content-disposition"] = *input.ContentDisposition + } + if input.ContentEncoding != nil { + headers["x-ms-blob-content-encoding"] = *input.ContentEncoding + } + if input.ContentLanguage != nil { + headers["x-ms-blob-content-language"] = *input.ContentLanguage + } + if input.ContentMD5 != nil { + headers["x-ms-blob-content-md5"] = *input.ContentMD5 + } + if input.ContentType != nil { + headers["x-ms-blob-content-type"] = *input.ContentType + } + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutPageBlobSender sends the PutPageBlob request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutPageBlobSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutPageBlobResponder handles the response to the PutPageBlob request. The method always +// closes the http.Response Body. +func (client Client) PutPageBlobResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go new file mode 100644 index 000000000000..59feaa5d93d0 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go @@ -0,0 +1,113 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type PutPageClearInput struct { + StartByte int64 + EndByte int64 + + LeaseID *string +} + +// PutPageClear clears a range of pages within a page blob. +func (client Client) PutPageClear(ctx context.Context, accountName, containerName, blobName string, input PutPageClearInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutPageClear", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutPageClear", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutPageClear", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutPageClear", "`blobName` cannot be an empty string.") + } + if input.StartByte < 0 { + return result, validation.NewError("blobs.Client", "PutPageClear", "`input.StartByte` must be greater than or equal to 0.") + } + if input.EndByte <= 0 { + return result, validation.NewError("blobs.Client", "PutPageClear", "`input.EndByte` must be greater than 0.") + } + + req, err := client.PutPageClearPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageClear", nil, "Failure preparing request") + return + } + + resp, err := client.PutPageClearSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageClear", resp, "Failure sending request") + return + } + + result, err = client.PutPageClearResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageClear", resp, "Failure responding to request") + return + } + + return +} + +// PutPageClearPreparer prepares the PutPageClear request. +func (client Client) PutPageClearPreparer(ctx context.Context, accountName, containerName, blobName string, input PutPageClearInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "page"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-page-write": "clear", + "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartByte, input.EndByte), + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutPageClearSender sends the PutPageClear request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutPageClearSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutPageClearResponder handles the response to the PutPageClear request. The method always +// closes the http.Response Body. +func (client Client) PutPageClearResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go new file mode 100644 index 000000000000..3799381e5525 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go @@ -0,0 +1,164 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type PutPageUpdateInput struct { + StartByte int64 + EndByte int64 + Content []byte + + IfSequenceNumberEQ *string + IfSequenceNumberLE *string + IfSequenceNumberLT *string + IfModifiedSince *string + IfUnmodifiedSince *string + IfMatch *string + IfNoneMatch *string + LeaseID *string +} + +type PutPageUpdateResult struct { + autorest.Response + + BlobSequenceNumber string + ContentMD5 string + LastModified string +} + +// PutPageUpdate writes a range of pages to a page blob. +func (client Client) PutPageUpdate(ctx context.Context, accountName, containerName, blobName string, input PutPageUpdateInput) (result PutPageUpdateResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "PutPageUpdate", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "PutPageUpdate", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "PutPageUpdate", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "PutPageUpdate", "`blobName` cannot be an empty string.") + } + if input.StartByte < 0 { + return result, validation.NewError("blobs.Client", "PutPageUpdate", "`input.StartByte` must be greater than or equal to 0.") + } + if input.EndByte <= 0 { + return result, validation.NewError("blobs.Client", "PutPageUpdate", "`input.EndByte` must be greater than 0.") + } + + expectedSize := (input.EndByte - input.StartByte) + 1 + actualSize := int64(len(input.Content)) + if expectedSize != actualSize { + return result, validation.NewError("blobs.Client", "PutPageUpdate", fmt.Sprintf("Content Size was defined as %d but got %d.", expectedSize, actualSize)) + } + + req, err := client.PutPageUpdatePreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageUpdate", nil, "Failure preparing request") + return + } + + resp, err := client.PutPageUpdateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageUpdate", resp, "Failure sending request") + return + } + + result, err = client.PutPageUpdateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageUpdate", resp, "Failure responding to request") + return + } + + return +} + +// PutPageUpdatePreparer prepares the PutPageUpdate request. +func (client Client) PutPageUpdatePreparer(ctx context.Context, accountName, containerName, blobName string, input PutPageUpdateInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "page"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-page-write": "update", + "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartByte, input.EndByte), + "Content-Length": int(len(input.Content)), + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + if input.IfSequenceNumberEQ != nil { + headers["x-ms-if-sequence-number-eq"] = *input.IfSequenceNumberEQ + } + if input.IfSequenceNumberLE != nil { + headers["x-ms-if-sequence-number-le"] = *input.IfSequenceNumberLE + } + if input.IfSequenceNumberLT != nil { + headers["x-ms-if-sequence-number-lt"] = *input.IfSequenceNumberLT + } + if input.IfModifiedSince != nil { + headers["If-Modified-Since"] = *input.IfModifiedSince + } + if input.IfUnmodifiedSince != nil { + headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince + } + if input.IfMatch != nil { + headers["If-Match"] = *input.IfMatch + } + if input.IfNoneMatch != nil { + headers["If-None-Match"] = *input.IfNoneMatch + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers), + autorest.WithBytes(&input.Content)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutPageUpdateSender sends the PutPageUpdate request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutPageUpdateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutPageUpdateResponder handles the response to the PutPageUpdate request. The method always +// closes the http.Response Body. +func (client Client) PutPageUpdateResponder(resp *http.Response) (result PutPageUpdateResult, err error) { + if resp != nil && resp.Header != nil { + result.BlobSequenceNumber = resp.Header.Get("x-ms-blob-sequence-number") + result.ContentMD5 = resp.Header.Get("Content-MD5") + result.LastModified = resp.Header.Get("Last-Modified") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go new file mode 100644 index 000000000000..4057cf275676 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go @@ -0,0 +1,56 @@ +package blobs + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Blob +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, containerName, blobName string) string { + domain := endpoints.GetBlobEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s/%s", domain, containerName, blobName) +} + +type ResourceID struct { + AccountName string + ContainerName string + BlobName string +} + +// ParseResourceID parses the Resource ID and returns an object which can be used +// to interact with the Blob Resource +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.blob.core.windows.net/Bar/example.vhd + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + path := strings.TrimPrefix(uri.Path, "/") + segments := strings.Split(path, "/") + if len(segments) == 0 { + return nil, fmt.Errorf("Expected the path to contain segments but got none") + } + + containerName := segments[0] + blobName := strings.TrimPrefix(path, containerName) + blobName = strings.TrimPrefix(blobName, "/") + return &ResourceID{ + AccountName: *accountName, + ContainerName: containerName, + BlobName: blobName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go new file mode 100644 index 000000000000..dd0f0b8782b1 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go @@ -0,0 +1,93 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// SetTier sets the tier on a blob. +func (client Client) SetTier(ctx context.Context, accountName, containerName, blobName string, tier AccessTier) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "SetTier", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "SetTier", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "SetTier", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "SetTier", "`blobName` cannot be an empty string.") + } + + req, err := client.SetTierPreparer(ctx, accountName, containerName, blobName, tier) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "SetTier", nil, "Failure preparing request") + return + } + + resp, err := client.SetTierSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "SetTier", resp, "Failure sending request") + return + } + + result, err = client.SetTierResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "SetTier", resp, "Failure responding to request") + return + } + + return +} + +// SetTierPreparer prepares the SetTier request. +func (client Client) SetTierPreparer(ctx context.Context, accountName, containerName, blobName string, tier AccessTier) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "tier"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-access-tier": string(tier), + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetTierSender sends the SetTier request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetTierSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetTierResponder handles the response to the SetTier request. The method always +// closes the http.Response Body. +func (client Client) SetTierResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go new file mode 100644 index 000000000000..180070b29469 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go @@ -0,0 +1,163 @@ +package blobs + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type SnapshotInput struct { + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string + + // MetaData is a user-defined name-value pair associated with the blob. + // If no name-value pairs are specified, the operation will copy the base blob metadata to the snapshot. + // If one or more name-value pairs are specified, the snapshot is created with the specified metadata, + // and metadata is not copied from the base blob. + MetaData map[string]string + + // A DateTime value which will only snapshot the blob if it has been modified since the specified date/time + // If the base blob has not been modified, the Blob service returns status code 412 (Precondition Failed). + IfModifiedSince *string + + // A DateTime value which will only snapshot the blob if it has not been modified since the specified date/time + // If the base blob has been modified, the Blob service returns status code 412 (Precondition Failed). + IfUnmodifiedSince *string + + // An ETag value to snapshot the blob only if its ETag value matches the value specified. + // If the values do not match, the Blob service returns status code 412 (Precondition Failed). + IfMatch *string + + // An ETag value for this conditional header to snapshot the blob only if its ETag value + // does not match the value specified. + // If the values are identical, the Blob service returns status code 412 (Precondition Failed). + IfNoneMatch *string +} + +type SnapshotResult struct { + autorest.Response + + // The ETag of the snapshot + ETag string + + // A DateTime value that uniquely identifies the snapshot. + // The value of this header indicates the snapshot version, + // and may be used in subsequent requests to access the snapshot. + SnapshotDateTime string +} + +// Snapshot captures a Snapshot of a given Blob +func (client Client) Snapshot(ctx context.Context, accountName, containerName, blobName string, input SnapshotInput) (result SnapshotResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "Snapshot", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "Snapshot", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "Snapshot", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "Snapshot", "`blobName` cannot be an empty string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("blobs.Client", "Snapshot", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.SnapshotPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Snapshot", nil, "Failure preparing request") + return + } + + resp, err := client.SnapshotSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "Snapshot", resp, "Failure sending request") + return + } + + result, err = client.SnapshotResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Snapshot", resp, "Failure responding to request") + return + } + + return +} + +// SnapshotPreparer prepares the Snapshot request. +func (client Client) SnapshotPreparer(ctx context.Context, accountName, containerName, blobName string, input SnapshotInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "snapshot"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + if input.IfModifiedSince != nil { + headers["If-Modified-Since"] = *input.IfModifiedSince + } + if input.IfUnmodifiedSince != nil { + headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince + } + if input.IfMatch != nil { + headers["If-Match"] = *input.IfMatch + } + if input.IfNoneMatch != nil { + headers["If-None-Match"] = *input.IfNoneMatch + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SnapshotSender sends the Snapshot request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SnapshotSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SnapshotResponder handles the response to the Snapshot request. The method always +// closes the http.Response Body. +func (client Client) SnapshotResponder(resp *http.Response) (result SnapshotResult, err error) { + if resp != nil && resp.Header != nil { + result.ETag = resp.Header.Get("ETag") + result.SnapshotDateTime = resp.Header.Get("x-ms-snapshot") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go new file mode 100644 index 000000000000..fe1be63ab216 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go @@ -0,0 +1,90 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetSnapshotPropertiesInput struct { + // The ID of the Lease + // This must be specified if a Lease is present on the Blob, else a 403 is returned + LeaseID *string + + // The ID of the Snapshot which should be retrieved + SnapshotID string +} + +// GetSnapshotProperties returns all user-defined metadata, standard HTTP properties, and system properties for +// the specified snapshot of a blob +func (client Client) GetSnapshotProperties(ctx context.Context, accountName, containerName, blobName string, input GetSnapshotPropertiesInput) (result GetPropertiesResult, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`blobName` cannot be an empty string.") + } + if input.SnapshotID == "" { + return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`input.SnapshotID` cannot be an empty string.") + } + + req, err := client.GetSnapshotPropertiesPreparer(ctx, accountName, containerName, blobName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetSnapshotProperties", nil, "Failure preparing request") + return + } + + // we re-use the GetProperties methods since this is otherwise the same + resp, err := client.GetPropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "GetSnapshotProperties", resp, "Failure sending request") + return + } + + result, err = client.GetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "GetSnapshotProperties", resp, "Failure responding to request") + return + } + + return +} + +// GetSnapshotPreparer prepares the GetSnapshot request. +func (client Client) GetSnapshotPropertiesPreparer(ctx context.Context, accountName, containerName, blobName string, input GetSnapshotPropertiesInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "snapshot": autorest.Encode("query", input.SnapshotID), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.LeaseID != nil { + headers["x-ms-lease-id"] = *input.LeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsHead(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go new file mode 100644 index 000000000000..9be2f81a66f2 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go @@ -0,0 +1,92 @@ +package blobs + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Undelete restores the contents and metadata of soft deleted blob and any associated soft deleted snapshots. +func (client Client) Undelete(ctx context.Context, accountName, containerName, blobName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("blobs.Client", "Undelete", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("blobs.Client", "Undelete", "`containerName` cannot be an empty string.") + } + if strings.ToLower(containerName) != containerName { + return result, validation.NewError("blobs.Client", "Undelete", "`containerName` must be a lower-cased string.") + } + if blobName == "" { + return result, validation.NewError("blobs.Client", "Undelete", "`blobName` cannot be an empty string.") + } + + req, err := client.UndeletePreparer(ctx, accountName, containerName, blobName) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Undelete", nil, "Failure preparing request") + return + } + + resp, err := client.UndeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "blobs.Client", "Undelete", resp, "Failure sending request") + return + } + + result, err = client.UndeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "blobs.Client", "Undelete", resp, "Failure responding to request") + return + } + + return +} + +// UndeletePreparer prepares the Undelete request. +func (client Client) UndeletePreparer(ctx context.Context, accountName, containerName, blobName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + "blobName": autorest.Encode("path", blobName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "undelete"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// UndeleteSender sends the Undelete request. The method will close the +// http.Response Body if it receives an error. +func (client Client) UndeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// UndeleteResponder handles the response to the Undelete request. The method always +// closes the http.Response Body. +func (client Client) UndeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go new file mode 100644 index 000000000000..b6d69e2233b5 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go @@ -0,0 +1,14 @@ +package blobs + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md new file mode 100644 index 000000000000..9d375483ee8e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md @@ -0,0 +1,45 @@ +## Blob Storage Container SDK for API version 2020-08-04 + +This package allows you to interact with the Containers Blob Storage API + +### Supported Authorizers + +* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) +* SharedKeyLite (Blob, File & Queue) + +Note: when using the `ListBlobs` operation, only `SharedKeyLite` authentication is supported. + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + containerName := "mycontainer" + + storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) + containersClient := containers.New() + containersClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + createInput := containers.CreateInput{ + AccessLevel: containers.Private, + } + if _, err := containersClient.Create(ctx, accountName, containerName, createInput); err != nil { + return fmt.Errorf("Error creating Container: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go new file mode 100644 index 000000000000..622f2b00eed7 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go @@ -0,0 +1,25 @@ +package containers + +import ( + "context" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageContainer interface { + Create(ctx context.Context, accountName, containerName string, input CreateInput) (result CreateResponse, err error) + Delete(ctx context.Context, accountName, containerName string) (result autorest.Response, err error) + GetProperties(ctx context.Context, accountName, containerName string) (ContainerProperties, error) + GetPropertiesWithLeaseID(ctx context.Context, accountName, containerName, leaseID string) (result ContainerProperties, err error) + AcquireLease(ctx context.Context, accountName, containerName string, input AcquireLeaseInput) (result AcquireLeaseResponse, err error) + BreakLease(ctx context.Context, accountName, containerName string, input BreakLeaseInput) (result BreakLeaseResponse, err error) + ChangeLease(ctx context.Context, accountName, containerName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) + ReleaseLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) + RenewLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) + ListBlobs(ctx context.Context, accountName, containerName string, input ListBlobsInput) (result ListBlobsResult, err error) + GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, containerName string) string + SetAccessControl(ctx context.Context, accountName, containerName string, level AccessLevel) (autorest.Response, error) + SetAccessControlWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, level AccessLevel) (result autorest.Response, err error) + SetMetaData(ctx context.Context, accountName, containerName string, metaData map[string]string) (autorest.Response, error) + SetMetaDataWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, metaData map[string]string) (result autorest.Response, err error) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go new file mode 100644 index 000000000000..7bf494734484 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go @@ -0,0 +1,34 @@ +package containers + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Blob Storage Containers. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithBaseURI creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} + +func (client Client) setAccessLevelIntoHeaders(headers map[string]interface{}, level AccessLevel) map[string]interface{} { + // If this header is not included in the request, container data is private to the account owner. + if level != Private { + headers["x-ms-blob-public-access"] = string(level) + } + + return headers +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go new file mode 100644 index 000000000000..84c2887d7d1a --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go @@ -0,0 +1,123 @@ +package containers + +import ( + "context" + "fmt" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type CreateInput struct { + // Specifies whether data in the container may be accessed publicly and the level of access + AccessLevel AccessLevel + + // A name-value pair to associate with the container as metadata. + MetaData map[string]string +} + +type CreateResponse struct { + autorest.Response + Error *ErrorResponse `xml:"Error"` +} + +// Create creates a new container under the specified account. +// If the container with the same name already exists, the operation fails. +func (client Client) Create(ctx context.Context, accountName, containerName string, input CreateInput) (result CreateResponse, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "Create", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "Create", "`containerName` cannot be an empty string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("containers.Client", "Create", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.CreatePreparer(ctx, accountName, containerName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "Create", resp, "Failure responding to request") + return + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName string, containerName string, input CreateInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = client.setAccessLevelIntoHeaders(headers, input.AccessLevel) + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result CreateResponse, err error) { + successfulStatusCodes := []int{ + http.StatusCreated, + } + if autorest.ResponseHasStatusCode(resp, successfulStatusCodes...) { + // when successful there's no response + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(successfulStatusCodes...), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + } else { + // however when there's an error the error's in the response + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(successfulStatusCodes...), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + } + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go new file mode 100644 index 000000000000..30958295388e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go @@ -0,0 +1,85 @@ +package containers + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete marks the specified container for deletion. +// The container and any blobs contained within it are later deleted during garbage collection. +func (client Client) Delete(ctx context.Context, accountName, containerName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "Delete", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "Delete", "`containerName` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, containerName) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName string, containerName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go new file mode 100644 index 000000000000..1e308da67c55 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go @@ -0,0 +1,124 @@ +package containers + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +// GetProperties returns the properties for this Container without a Lease +func (client Client) GetProperties(ctx context.Context, accountName, containerName string) (ContainerProperties, error) { + // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. + // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. + return client.GetPropertiesWithLeaseID(ctx, accountName, containerName, "") +} + +// GetPropertiesWithLeaseID returns the properties for this Container using the specified LeaseID +func (client Client) GetPropertiesWithLeaseID(ctx context.Context, accountName, containerName, leaseID string) (result ContainerProperties, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "GetPropertiesWithLeaseID", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "GetPropertiesWithLeaseID", "`containerName` cannot be an empty string.") + } + + req, err := client.GetPropertiesWithLeaseIDPreparer(ctx, accountName, containerName, leaseID) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "GetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetPropertiesWithLeaseIDSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "GetProperties", resp, "Failure sending request") + return + } + + result, err = client.GetPropertiesWithLeaseIDResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "GetProperties", resp, "Failure responding to request") + return + } + + return +} + +// GetPropertiesWithLeaseIDPreparer prepares the GetPropertiesWithLeaseID request. +func (client Client) GetPropertiesWithLeaseIDPreparer(ctx context.Context, accountName, containerName, leaseID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. + // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. + if leaseID != "" { + headers["x-ms-lease-id"] = leaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetPropertiesWithLeaseIDSender sends the GetPropertiesWithLeaseID request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetPropertiesWithLeaseIDSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetPropertiesWithLeaseIDResponder handles the response to the GetPropertiesWithLeaseID request. The method always +// closes the http.Response Body. +func (client Client) GetPropertiesWithLeaseIDResponder(resp *http.Response) (result ContainerProperties, err error) { + if resp != nil { + result.LeaseStatus = LeaseStatus(resp.Header.Get("x-ms-lease-status")) + result.LeaseState = LeaseState(resp.Header.Get("x-ms-lease-state")) + if result.LeaseStatus == Locked { + duration := LeaseDuration(resp.Header.Get("x-ms-lease-duration")) + result.LeaseDuration = &duration + } + + // If this header is not returned in the response, the container is private to the account owner. + accessLevel := resp.Header.Get("x-ms-blob-public-access") + if accessLevel != "" { + result.AccessLevel = AccessLevel(accessLevel) + } else { + result.AccessLevel = Private + } + + // we can't necessarily use strconv.ParseBool here since this could be nil (only in some API versions) + result.HasImmutabilityPolicy = strings.EqualFold(resp.Header.Get("x-ms-has-immutability-policy"), "true") + result.HasLegalHold = strings.EqualFold(resp.Header.Get("x-ms-has-legal-hold"), "true") + + result.MetaData = metadata.ParseFromHeaders(resp.Header) + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go new file mode 100644 index 000000000000..061c863c43f9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go @@ -0,0 +1,115 @@ +package containers + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type AcquireLeaseInput struct { + // Specifies the duration of the lease, in seconds, or negative one (-1) for a lease that never expires. + // A non-infinite lease can be between 15 and 60 seconds + LeaseDuration int + + ProposedLeaseID string +} + +type AcquireLeaseResponse struct { + autorest.Response + + LeaseID string +} + +// AcquireLease establishes and manages a lock on a container for delete operations. +func (client Client) AcquireLease(ctx context.Context, accountName, containerName string, input AcquireLeaseInput) (result AcquireLeaseResponse, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "AcquireLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "AcquireLease", "`containerName` cannot be an empty string.") + } + // An infinite lease duration is -1 seconds. A non-infinite lease can be between 15 and 60 seconds + if input.LeaseDuration != -1 && (input.LeaseDuration <= 15 || input.LeaseDuration >= 60) { + return result, validation.NewError("containers.Client", "AcquireLease", "`input.LeaseDuration` must be -1 (infinite), or between 15 and 60 seconds.") + } + + req, err := client.AcquireLeasePreparer(ctx, accountName, containerName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "AcquireLease", nil, "Failure preparing request") + return + } + + resp, err := client.AcquireLeaseSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "AcquireLease", resp, "Failure sending request") + return + } + + result, err = client.AcquireLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "AcquireLease", resp, "Failure responding to request") + return + } + + return +} + +// AcquireLeasePreparer prepares the AcquireLease request. +func (client Client) AcquireLeasePreparer(ctx context.Context, accountName string, containerName string, input AcquireLeaseInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + "comp": autorest.Encode("path", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "acquire", + "x-ms-lease-duration": input.LeaseDuration, + } + + if input.ProposedLeaseID != "" { + headers["x-ms-proposed-lease-id"] = input.ProposedLeaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// AcquireLeaseSender sends the AcquireLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) AcquireLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// AcquireLeaseResponder handles the response to the AcquireLease request. The method always +// closes the http.Response Body. +func (client Client) AcquireLeaseResponder(resp *http.Response) (result AcquireLeaseResponse, err error) { + if resp != nil { + result.LeaseID = resp.Header.Get("x-ms-lease-id") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go new file mode 100644 index 000000000000..08acfb7a3116 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go @@ -0,0 +1,129 @@ +package containers + +import ( + "context" + "net/http" + "strconv" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type BreakLeaseInput struct { + // For a break operation, proposed duration the lease should continue + // before it is broken, in seconds, between 0 and 60. + // This break period is only used if it is shorter than the time remaining on the lease. + // If longer, the time remaining on the lease is used. + // A new lease will not be available before the break period has expired, + // but the lease may be held for longer than the break period. + // If this header does not appear with a break operation, a fixed-duration lease breaks + // after the remaining lease period elapses, and an infinite lease breaks immediately. + BreakPeriod *int + + LeaseID string +} + +type BreakLeaseResponse struct { + autorest.Response + + // Approximate time remaining in the lease period, in seconds. + // If the break is immediate, 0 is returned. + LeaseTime int +} + +// BreakLease breaks a lock based on it's Lease ID +func (client Client) BreakLease(ctx context.Context, accountName, containerName string, input BreakLeaseInput) (result BreakLeaseResponse, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "BreakLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "BreakLease", "`containerName` cannot be an empty string.") + } + if input.LeaseID == "" { + return result, validation.NewError("containers.Client", "BreakLease", "`input.LeaseID` cannot be an empty string.") + } + + req, err := client.BreakLeasePreparer(ctx, accountName, containerName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "BreakLease", nil, "Failure preparing request") + return + } + + resp, err := client.BreakLeaseSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "BreakLease", resp, "Failure sending request") + return + } + + result, err = client.BreakLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "BreakLease", resp, "Failure responding to request") + return + } + + return +} + +// BreakLeasePreparer prepares the BreakLease request. +func (client Client) BreakLeasePreparer(ctx context.Context, accountName string, containerName string, input BreakLeaseInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + "comp": autorest.Encode("path", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "break", + "x-ms-lease-id": input.LeaseID, + } + + if input.BreakPeriod != nil { + headers["x-ms-lease-break-period"] = *input.BreakPeriod + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// BreakLeaseSender sends the BreakLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) BreakLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// BreakLeaseResponder handles the response to the BreakLease request. The method always +// closes the http.Response Body. +func (client Client) BreakLeaseResponder(resp *http.Response) (result BreakLeaseResponse, err error) { + if resp != nil { + leaseRaw := resp.Header.Get("x-ms-lease-time") + if leaseRaw != "" { + i, err := strconv.Atoi(leaseRaw) + if err == nil { + result.LeaseTime = i + } + } + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go new file mode 100644 index 000000000000..dfbcb132dae3 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go @@ -0,0 +1,111 @@ +package containers + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type ChangeLeaseInput struct { + ExistingLeaseID string + ProposedLeaseID string +} + +type ChangeLeaseResponse struct { + autorest.Response + + LeaseID string +} + +// ChangeLease changes the lock from one Lease ID to another Lease ID +func (client Client) ChangeLease(ctx context.Context, accountName, containerName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "ChangeLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "ChangeLease", "`containerName` cannot be an empty string.") + } + if input.ExistingLeaseID == "" { + return result, validation.NewError("containers.Client", "ChangeLease", "`input.ExistingLeaseID` cannot be an empty string.") + } + if input.ProposedLeaseID == "" { + return result, validation.NewError("containers.Client", "ChangeLease", "`input.ProposedLeaseID` cannot be an empty string.") + } + + req, err := client.ChangeLeasePreparer(ctx, accountName, containerName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "ChangeLease", nil, "Failure preparing request") + return + } + + resp, err := client.ChangeLeaseSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "ChangeLease", resp, "Failure sending request") + return + } + + result, err = client.ChangeLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "ChangeLease", resp, "Failure responding to request") + return + } + + return +} + +// ChangeLeasePreparer prepares the ChangeLease request. +func (client Client) ChangeLeasePreparer(ctx context.Context, accountName string, containerName string, input ChangeLeaseInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + "comp": autorest.Encode("path", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "change", + "x-ms-lease-id": input.ExistingLeaseID, + "x-ms-proposed-lease-id": input.ProposedLeaseID, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ChangeLeaseSender sends the ChangeLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ChangeLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ChangeLeaseResponder handles the response to the ChangeLease request. The method always +// closes the http.Response Body. +func (client Client) ChangeLeaseResponder(resp *http.Response) (result ChangeLeaseResponse, err error) { + if resp != nil { + result.LeaseID = resp.Header.Get("x-ms-lease-id") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go new file mode 100644 index 000000000000..fafcf98f1e67 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go @@ -0,0 +1,92 @@ +package containers + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// ReleaseLease releases the lock based on the Lease ID +func (client Client) ReleaseLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "ReleaseLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "ReleaseLease", "`containerName` cannot be an empty string.") + } + if leaseID == "" { + return result, validation.NewError("containers.Client", "ReleaseLease", "`leaseID` cannot be an empty string.") + } + + req, err := client.ReleaseLeasePreparer(ctx, accountName, containerName, leaseID) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "ReleaseLease", nil, "Failure preparing request") + return + } + + resp, err := client.ReleaseLeaseSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "ReleaseLease", resp, "Failure sending request") + return + } + + result, err = client.ReleaseLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "ReleaseLease", resp, "Failure responding to request") + return + } + + return +} + +// ReleaseLeasePreparer prepares the ReleaseLease request. +func (client Client) ReleaseLeasePreparer(ctx context.Context, accountName string, containerName string, leaseID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + "comp": autorest.Encode("path", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "release", + "x-ms-lease-id": leaseID, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ReleaseLeaseSender sends the ReleaseLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ReleaseLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ReleaseLeaseResponder handles the response to the ReleaseLease request. The method always +// closes the http.Response Body. +func (client Client) ReleaseLeaseResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go new file mode 100644 index 000000000000..cab50bff9d21 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go @@ -0,0 +1,92 @@ +package containers + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// RenewLease renews the lock based on the Lease ID +func (client Client) RenewLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "RenewLease", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "RenewLease", "`containerName` cannot be an empty string.") + } + if leaseID == "" { + return result, validation.NewError("containers.Client", "RenewLease", "`leaseID` cannot be an empty string.") + } + + req, err := client.RenewLeasePreparer(ctx, accountName, containerName, leaseID) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "RenewLease", nil, "Failure preparing request") + return + } + + resp, err := client.RenewLeaseSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "RenewLease", resp, "Failure sending request") + return + } + + result, err = client.RenewLeaseResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "RenewLease", resp, "Failure responding to request") + return + } + + return +} + +// RenewLeasePreparer prepares the RenewLease request. +func (client Client) RenewLeasePreparer(ctx context.Context, accountName string, containerName string, leaseID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "container"), + "comp": autorest.Encode("path", "lease"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-lease-action": "renew", + "x-ms-lease-id": leaseID, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// RenewLeaseSender sends the RenewLease request. The method will close the +// http.Response Body if it receives an error. +func (client Client) RenewLeaseSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// RenewLeaseResponder handles the response to the RenewLease request. The method always +// closes the http.Response Body. +func (client Client) RenewLeaseResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go new file mode 100644 index 000000000000..82797d091d36 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go @@ -0,0 +1,179 @@ +package containers + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type ListBlobsInput struct { + Delimiter *string + Include *[]Dataset + Marker *string + MaxResults *int + Prefix *string +} + +type ListBlobsResult struct { + autorest.Response + + Delimiter string `xml:"Delimiter"` + Marker string `xml:"Marker"` + MaxResults int `xml:"MaxResults"` + NextMarker *string `xml:"NextMarker,omitempty"` + Prefix string `xml:"Prefix"` + Blobs Blobs `xml:"Blobs"` +} + +type Blobs struct { + Blobs []BlobDetails `xml:"Blob"` + BlobPrefix *BlobPrefix `xml:"BlobPrefix"` +} + +type BlobDetails struct { + Name string `xml:"Name"` + Deleted bool `xml:"Deleted,omitempty"` + MetaData map[string]interface{} `map:"Metadata,omitempty"` + Properties *BlobProperties `xml:"Properties,omitempty"` + Snapshot *string `xml:"Snapshot,omitempty"` +} + +type BlobProperties struct { + AccessTier *string `xml:"AccessTier,omitempty"` + AccessTierInferred *bool `xml:"AccessTierInferred,omitempty"` + AccessTierChangeTime *string `xml:"AccessTierChangeTime,omitempty"` + BlobType *string `xml:"BlobType,omitempty"` + BlobSequenceNumber *string `xml:"x-ms-blob-sequence-number,omitempty"` + CacheControl *string `xml:"Cache-Control,omitempty"` + ContentEncoding *string `xml:"ContentEncoding,omitempty"` + ContentLanguage *string `xml:"Content-Language,omitempty"` + ContentLength *int64 `xml:"Content-Length,omitempty"` + ContentMD5 *string `xml:"Content-MD5,omitempty"` + ContentType *string `xml:"Content-Type,omitempty"` + CopyCompletionTime *string `xml:"CopyCompletionTime,omitempty"` + CopyId *string `xml:"CopyId,omitempty"` + CopyStatus *string `xml:"CopyStatus,omitempty"` + CopySource *string `xml:"CopySource,omitempty"` + CopyProgress *string `xml:"CopyProgress,omitempty"` + CopyStatusDescription *string `xml:"CopyStatusDescription,omitempty"` + CreationTime *string `xml:"CreationTime,omitempty"` + ETag *string `xml:"Etag,omitempty"` + DeletedTime *string `xml:"DeletedTime,omitempty"` + IncrementalCopy *bool `xml:"IncrementalCopy,omitempty"` + LastModified *string `xml:"Last-Modified,omitempty"` + LeaseDuration *string `xml:"LeaseDuration,omitempty"` + LeaseState *string `xml:"LeaseState,omitempty"` + LeaseStatus *string `xml:"LeaseStatus,omitempty"` + RemainingRetentionDays *string `xml:"RemainingRetentionDays,omitempty"` + ServerEncrypted *bool `xml:"ServerEncrypted,omitempty"` +} + +type BlobPrefix struct { + Name string `xml:"Name"` +} + +// ListBlobs lists the blobs matching the specified query within the specified Container +func (client Client) ListBlobs(ctx context.Context, accountName, containerName string, input ListBlobsInput) (result ListBlobsResult, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "ListBlobs", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "ListBlobs", "`containerName` cannot be an empty string.") + } + if input.MaxResults != nil && (*input.MaxResults <= 0 || *input.MaxResults > 5000) { + return result, validation.NewError("containers.Client", "ListBlobs", "`input.MaxResults` can either be nil or between 0 and 5000.") + } + + req, err := client.ListBlobsPreparer(ctx, accountName, containerName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "ListBlobs", nil, "Failure preparing request") + return + } + + resp, err := client.ListBlobsSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "ListBlobs", resp, "Failure sending request") + return + } + + result, err = client.ListBlobsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "ListBlobs", resp, "Failure responding to request") + return + } + + return +} + +// ListBlobsPreparer prepares the ListBlobs request. +func (client Client) ListBlobsPreparer(ctx context.Context, accountName, containerName string, input ListBlobsInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "list"), + "restype": autorest.Encode("query", "container"), + } + + if input.Delimiter != nil { + queryParameters["delimiter"] = autorest.Encode("query", *input.Delimiter) + } + if input.Include != nil { + vals := make([]string, 0) + for _, v := range *input.Include { + vals = append(vals, string(v)) + } + include := strings.Join(vals, ",") + queryParameters["include"] = autorest.Encode("query", include) + } + if input.Marker != nil { + queryParameters["marker"] = autorest.Encode("query", *input.Marker) + } + if input.MaxResults != nil { + queryParameters["maxresults"] = autorest.Encode("query", *input.MaxResults) + } + if input.Prefix != nil { + queryParameters["prefix"] = autorest.Encode("query", *input.Prefix) + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListBlobsSender sends the ListBlobs request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ListBlobsSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ListBlobsResponder handles the response to the ListBlobs request. The method always +// closes the http.Response Body. +func (client Client) ListBlobsResponder(resp *http.Response) (result ListBlobsResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go new file mode 100644 index 000000000000..adba36818aa1 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go @@ -0,0 +1,75 @@ +package containers + +import "github.com/Azure/go-autorest/autorest" + +type AccessLevel string + +var ( + // Blob specifies public read access for blobs. + // Blob data within this container can be read via anonymous request, + // but container data is not available. + // Clients cannot enumerate blobs within the container via anonymous request. + Blob AccessLevel = "blob" + + // Container specifies full public read access for container and blob data. + // Clients can enumerate blobs within the container via anonymous request, + // but cannot enumerate containers within the storage account. + Container AccessLevel = "container" + + // Private specifies that container data is private to the account owner + Private AccessLevel = "" +) + +type ContainerProperties struct { + autorest.Response + + AccessLevel AccessLevel + LeaseStatus LeaseStatus + LeaseState LeaseState + LeaseDuration *LeaseDuration + MetaData map[string]string + HasImmutabilityPolicy bool + HasLegalHold bool +} + +type Dataset string + +var ( + Copy Dataset = "copy" + Deleted Dataset = "deleted" + MetaData Dataset = "metadata" + Snapshots Dataset = "snapshots" + UncommittedBlobs Dataset = "uncommittedblobs" +) + +type ErrorResponse struct { + Code *string `xml:"Code"` + Message *string `xml:"Message"` +} + +type LeaseDuration string + +var ( + // If this lease is for a Fixed Duration + Fixed LeaseDuration = "fixed" + + // If this lease is for an Indefinite Duration + Infinite LeaseDuration = "infinite" +) + +type LeaseState string + +var ( + Available LeaseState = "available" + Breaking LeaseState = "breaking" + Broken LeaseState = "broken" + Expired LeaseState = "expired" + Leased LeaseState = "leased" +) + +type LeaseStatus string + +var ( + Locked LeaseStatus = "locked" + Unlocked LeaseStatus = "unlocked" +) diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go new file mode 100644 index 000000000000..d35674a7868d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go @@ -0,0 +1,53 @@ +package containers + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Container +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, containerName string) string { + domain := endpoints.GetBlobEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s", domain, containerName) +} + +// GetResourceManagerResourceID returns the Resource Manager specific +// ResourceID for a specific Storage Container +func (client Client) GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, containerName string) string { + fmtStr := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Storage/storageAccounts/%s/blobServices/default/containers/%s" + return fmt.Sprintf(fmtStr, subscriptionID, resourceGroup, accountName, containerName) +} + +type ResourceID struct { + AccountName string + ContainerName string +} + +// ParseResourceID parses the Resource ID and returns an object which can be used +// to interact with the Container Resource +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.blob.core.windows.net/Bar + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + containerName := strings.TrimPrefix(uri.Path, "/") + return &ResourceID{ + AccountName: *accountName, + ContainerName: containerName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go new file mode 100644 index 000000000000..fcf4e1056fa4 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go @@ -0,0 +1,100 @@ +package containers + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// SetAccessControl sets the Access Control for a Container without a Lease ID +func (client Client) SetAccessControl(ctx context.Context, accountName, containerName string, level AccessLevel) (autorest.Response, error) { + return client.SetAccessControlWithLeaseID(ctx, accountName, containerName, "", level) +} + +// SetAccessControlWithLeaseID sets the Access Control for a Container using the specified Lease ID +func (client Client) SetAccessControlWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, level AccessLevel) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "SetAccessControl", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "SetAccessControl", "`containerName` cannot be an empty string.") + } + + req, err := client.SetAccessControlWithLeaseIDPreparer(ctx, accountName, containerName, leaseID, level) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "SetAccessControl", nil, "Failure preparing request") + return + } + + resp, err := client.SetAccessControlWithLeaseIDSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "SetAccessControl", resp, "Failure sending request") + return + } + + result, err = client.SetAccessControlWithLeaseIDResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "SetAccessControl", resp, "Failure responding to request") + return + } + + return +} + +// SetAccessControlWithLeaseIDPreparer prepares the SetAccessControlWithLeaseID request. +func (client Client) SetAccessControlWithLeaseIDPreparer(ctx context.Context, accountName, containerName, leaseID string, level AccessLevel) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "acl"), + "restype": autorest.Encode("path", "container"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = client.setAccessLevelIntoHeaders(headers, level) + + // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. + // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. + if leaseID != "" { + headers["x-ms-lease-id"] = leaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetAccessControlWithLeaseIDSender sends the SetAccessControlWithLeaseID request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetAccessControlWithLeaseIDSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetAccessControlWithLeaseIDResponder handles the response to the SetAccessControlWithLeaseID request. The method always +// closes the http.Response Body. +func (client Client) SetAccessControlWithLeaseIDResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go new file mode 100644 index 000000000000..fb9e07fdefa9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go @@ -0,0 +1,105 @@ +package containers + +import ( + "context" + "fmt" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +// SetMetaData sets the specified MetaData on the Container without a Lease ID +func (client Client) SetMetaData(ctx context.Context, accountName, containerName string, metaData map[string]string) (autorest.Response, error) { + return client.SetMetaDataWithLeaseID(ctx, accountName, containerName, "", metaData) +} + +// SetMetaDataWithLeaseID sets the specified MetaData on the Container using the specified Lease ID +func (client Client) SetMetaDataWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, metaData map[string]string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("containers.Client", "SetMetaData", "`accountName` cannot be an empty string.") + } + if containerName == "" { + return result, validation.NewError("containers.Client", "SetMetaData", "`containerName` cannot be an empty string.") + } + if err := metadata.Validate(metaData); err != nil { + return result, validation.NewError("containers.Client", "SetMetaData", fmt.Sprintf("`metaData` is not valid: %s.", err)) + } + + req, err := client.SetMetaDataWithLeaseIDPreparer(ctx, accountName, containerName, leaseID, metaData) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "SetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.SetMetaDataWithLeaseIDSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "containers.Client", "SetMetaData", resp, "Failure sending request") + return + } + + result, err = client.SetMetaDataWithLeaseIDResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "containers.Client", "SetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// SetMetaDataWithLeaseIDPreparer prepares the SetMetaDataWithLeaseID request. +func (client Client) SetMetaDataWithLeaseIDPreparer(ctx context.Context, accountName, containerName, leaseID string, metaData map[string]string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "containerName": autorest.Encode("path", containerName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "metadata"), + "restype": autorest.Encode("path", "container"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = metadata.SetIntoHeaders(headers, metaData) + + // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. + // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. + if leaseID != "" { + headers["x-ms-lease-id"] = leaseID + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{containerName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetMetaDataWithLeaseIDSender sends the SetMetaDataWithLeaseID request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetMetaDataWithLeaseIDSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetMetaDataWithLeaseIDResponder handles the response to the SetMetaDataWithLeaseID request. The method always +// closes the http.Response Body. +func (client Client) SetMetaDataWithLeaseIDResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go new file mode 100644 index 000000000000..d3138cb35875 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go @@ -0,0 +1,14 @@ +package containers + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md new file mode 100644 index 000000000000..be6fb76139d5 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md @@ -0,0 +1,84 @@ +## Data Lake Storage Gen2 File Systems SDK for API version 2020-08-04 + +This package allows you to interact with the Data Lake Storage Gen2 File Systems API + +### Supported Authorizers + +* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "os" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/adal" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/hashicorp/go-azure-helpers/authentication" + "github.com/hashicorp/go-azure-helpers/sender" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems" +) + +func Example() error { + accountName := "storageaccount1" + fileSystemName := "filesystem1" + + builder := &authentication.Builder{ + SubscriptionID: os.Getenv("ARM_SUBSCRIPTION_ID"), + ClientID: os.Getenv("ARM_CLIENT_ID"), + ClientSecret: os.Getenv("ARM_CLIENT_SECRET"), + TenantID: os.Getenv("ARM_TENANT_ID"), + Environment: os.Getenv("ARM_ENVIRONMENT"), + + // Feature Toggles + SupportsClientSecretAuth: true, + } + + c, err := builder.Build() + if err != nil { + return fmt.Errorf("Error building AzureRM Client: %s", err) + } + + env, err := authentication.DetermineEnvironment(c.Environment) + if err != nil { + return err + } + + oauthConfig, err := adal.NewOAuthConfig(env.ActiveDirectoryEndpoint, c.TenantID) + if err != nil { + return err + } + + // OAuthConfigForTenant returns a pointer, which can be nil. + if oauthConfig == nil { + return fmt.Errorf("Unable to configure OAuthConfig for tenant %s", c.TenantID) + } + + sender := sender.BuildSender("AzureRM") + ctx := context.Background() + + storageAuth, err := config.GetAuthorizationToken(sender, oauthConfig, "https://storage.azure.com/") + if err != nil { + return fmt.Errorf("Error retrieving Authorization Token") + } + + + fileSystemsClient := filesystems.NewWithEnvironment(env) + fileSystemsClient.Client.Authorizer = storageAuth + + input := filesystems.CreateInput{ + Properties: map[string]string{}, + } + if _, err = fileSystemsClient.Create(ctx, accountName, fileSystemName, input); err != nil { + return fmt.Errorf("Error creating: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go new file mode 100644 index 000000000000..91d3fe1cf45e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go @@ -0,0 +1,25 @@ +package filesystems + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Data Lake Storage FileSystem +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Data Lake Storage FileSystem client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Data Lake Storage FileSystem client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go new file mode 100644 index 000000000000..4217cb80af0e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go @@ -0,0 +1,94 @@ +package filesystems + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type CreateInput struct { + // A map of base64-encoded strings to store as user-defined properties with the File System + // Note that items may only contain ASCII characters in the ISO-8859-1 character set. + // This automatically gets converted to a comma-separated list of name and + // value pairs before sending to the API + Properties map[string]string +} + +// Create creates a Data Lake Store Gen2 FileSystem within a Storage Account +func (client Client) Create(ctx context.Context, accountName string, fileSystemName string, input CreateInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "Create", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "Create", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.CreatePreparer(ctx, accountName, fileSystemName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure responding to request") + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName string, fileSystemName string, input CreateInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + } + + queryParameters := map[string]interface{}{ + "resource": autorest.Encode("query", "filesystem"), + } + + headers := map[string]interface{}{ + "x-ms-properties": buildProperties(input.Properties), + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go new file mode 100644 index 000000000000..fabc589da940 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go @@ -0,0 +1,85 @@ +package filesystems + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete deletes a Data Lake Store Gen2 FileSystem within a Storage Account +func (client Client) Delete(ctx context.Context, accountName string, fileSystemName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "Delete", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "Delete", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, fileSystemName) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure responding to request") + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName string, fileSystemName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + } + + queryParameters := map[string]interface{}{ + "resource": autorest.Encode("query", "filesystem"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go new file mode 100644 index 000000000000..605ed425929d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go @@ -0,0 +1,40 @@ +package filesystems + +import ( + "fmt" + "strings" +) + +func buildProperties(input map[string]string) string { + // properties has to be a comma-separated key-value pair + properties := make([]string, 0) + + for k, v := range input { + properties = append(properties, fmt.Sprintf("%s=%s", k, v)) + } + + return strings.Join(properties, ",") +} + +func parseProperties(input string) (*map[string]string, error) { + properties := make(map[string]string) + if input == "" { + return &properties, nil + } + + // properties is a comma-separated list of key-value pairs + splitProperties := strings.Split(input, ",") + for _, propertyRaw := range splitProperties { + // because these are base64-encoded they're likely to end in at least one = + // as such we can't string split on that -_- + position := strings.Index(propertyRaw, "=") + if position < 0 { + return nil, fmt.Errorf("Expected there to be an equals in the key value pair: %q", propertyRaw) + } + + key := propertyRaw[0:position] + value := propertyRaw[position+1:] + properties[key] = value + } + return &properties, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go new file mode 100644 index 000000000000..0b96c95edd52 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go @@ -0,0 +1,112 @@ +package filesystems + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetPropertiesResponse struct { + autorest.Response + + // A map of base64-encoded strings to store as user-defined properties with the File System + // Note that items may only contain ASCII characters in the ISO-8859-1 character set. + // This automatically gets converted to a comma-separated list of name and + // value pairs before sending to the API + Properties map[string]string + + // Is Hierarchical Namespace Enabled? + NamespaceEnabled bool +} + +// GetProperties gets the properties for a Data Lake Store Gen2 FileSystem within a Storage Account +func (client Client) GetProperties(ctx context.Context, accountName string, fileSystemName string) (result GetPropertiesResponse, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "GetProperties", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "GetProperties", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.GetPropertiesPreparer(ctx, accountName, fileSystemName) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetPropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure sending request") + return + } + + result, err = client.GetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure responding to request") + } + + return +} + +// GetPropertiesPreparer prepares the GetProperties request. +func (client Client) GetPropertiesPreparer(ctx context.Context, accountName string, fileSystemName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + } + + queryParameters := map[string]interface{}{ + "resource": autorest.Encode("query", "filesystem"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsHead(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + + 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetPropertiesResponder handles the response to the GetProperties request. The method always +// closes the http.Response Body. +func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResponse, err error) { + if resp != nil && resp.Header != nil { + + propertiesRaw := resp.Header.Get("x-ms-properties") + var properties *map[string]string + properties, err = parseProperties(propertiesRaw) + if err != nil { + return + } + + result.Properties = *properties + result.NamespaceEnabled = strings.EqualFold(resp.Header.Get("x-ms-namespace-enabled"), "tru") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go new file mode 100644 index 000000000000..dde02a4455b9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go @@ -0,0 +1,109 @@ +package filesystems + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type SetPropertiesInput struct { + // A map of base64-encoded strings to store as user-defined properties with the File System + // Note that items may only contain ASCII characters in the ISO-8859-1 character set. + // This automatically gets converted to a comma-separated list of name and + // value pairs before sending to the API + Properties map[string]string + + // Optional - A date and time value. + // Specify this header to perform the operation only if the resource has been modified since the specified date and time. + IfModifiedSince *string + + // Optional - A date and time value. + // Specify this header to perform the operation only if the resource has not been modified since the specified date and time. + IfUnmodifiedSince *string +} + +// SetProperties sets the Properties for a Data Lake Store Gen2 FileSystem within a Storage Account +func (client Client) SetProperties(ctx context.Context, accountName string, fileSystemName string, input SetPropertiesInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "SetProperties", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "SetProperties", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.SetPropertiesPreparer(ctx, accountName, fileSystemName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.SetPropertiesSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetProperties", resp, "Failure sending request") + return + } + + result, err = client.SetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetProperties", resp, "Failure responding to request") + } + + return +} + +// SetPropertiesPreparer prepares the SetProperties request. +func (client Client) SetPropertiesPreparer(ctx context.Context, accountName string, fileSystemName string, input SetPropertiesInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + } + + queryParameters := map[string]interface{}{ + "resource": autorest.Encode("query", "filesystem"), + } + + headers := map[string]interface{}{ + "x-ms-properties": buildProperties(input.Properties), + "x-ms-version": APIVersion, + } + + if input.IfModifiedSince != nil { + headers["If-Modified-Since"] = *input.IfModifiedSince + } + if input.IfUnmodifiedSince != nil { + headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince + } + + preparer := autorest.CreatePreparer( + autorest.AsPatch(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetPropertiesSender sends the SetProperties request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetPropertiesResponder handles the response to the SetProperties request. The method always +// closes the http.Response Body. +func (client Client) SetPropertiesResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go new file mode 100644 index 000000000000..34797b20b7a9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go @@ -0,0 +1,46 @@ +package filesystems + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Data Lake Storage FileSystem +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, shareName string) string { + domain := endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s", domain, shareName) +} + +type ResourceID struct { + AccountName string + DirectoryName string +} + +// ParseResourceID parses the specified Resource ID and returns an object +// which can be used to interact with the Data Lake Storage FileSystem API's +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.dfs.core.windows.net/Bar + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + directoryName := strings.TrimPrefix(uri.Path, "/") + return &ResourceID{ + AccountName: *accountName, + DirectoryName: directoryName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go new file mode 100644 index 000000000000..7447ea9ade09 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go @@ -0,0 +1,14 @@ +package filesystems + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go new file mode 100644 index 000000000000..3fb087bf8c8d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go @@ -0,0 +1,25 @@ +package paths + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Data Lake Storage Path +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Data Lake Storage Path client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Data Lake Storage Path client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go new file mode 100644 index 000000000000..600bd75a9a87 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go @@ -0,0 +1,95 @@ +package paths + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type PathResource string + +const PathResourceFile PathResource = "file" +const PathResourceDirectory PathResource = "directory" + +type CreateInput struct { + Resource PathResource +} + +// Create creates a Data Lake Store Gen2 Path within a Storage Account +func (client Client) Create(ctx context.Context, accountName string, fileSystemName string, path string, input CreateInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "Create", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "Create", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.CreatePreparer(ctx, accountName, fileSystemName, path, input) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure responding to request") + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName string, fileSystemName string, path string, input CreateInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + "path": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "resource": autorest.Encode("query", input.Resource), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go new file mode 100644 index 000000000000..078be57915af --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go @@ -0,0 +1,81 @@ +package paths + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete deletes a Data Lake Store Gen2 FileSystem within a Storage Account +func (client Client) Delete(ctx context.Context, accountName string, fileSystemName string, path string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "Delete", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "Delete", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, fileSystemName, path) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure responding to request") + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName string, fileSystemName string, path string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + "path": autorest.Encode("path", path), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), + autorest.WithHeaders(headers)) + + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go new file mode 100644 index 000000000000..e6ef6f4bfb9f --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go @@ -0,0 +1,15 @@ +package paths + +import ( + "fmt" +) + +func parsePathResource(input string) (PathResource, error) { + switch input { + case "file": + return PathResourceFile, nil + case "directory": + return PathResourceDirectory, nil + } + return "", fmt.Errorf("Unhandled path resource type %q", input) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go new file mode 100644 index 000000000000..263dc53ed95b --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go @@ -0,0 +1,134 @@ +package paths + +import ( + "context" + "net/http" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetPropertiesResponse struct { + autorest.Response + + ETag string + LastModified time.Time + // ResourceType is only returned for GetPropertiesActionGetStatus requests + ResourceType PathResource + Owner string + Group string + // ACL is only returned for GetPropertiesActionGetAccessControl requests + ACL string +} + +type GetPropertiesAction string + +const ( + GetPropertiesActionGetStatus GetPropertiesAction = "getStatus" + GetPropertiesActionGetAccessControl GetPropertiesAction = "getAccessControl" +) + +// GetProperties gets the properties for a Data Lake Store Gen2 Path in a FileSystem within a Storage Account +func (client Client) GetProperties(ctx context.Context, accountName string, fileSystemName string, path string, action GetPropertiesAction) (result GetPropertiesResponse, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "GetProperties", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "GetProperties", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.GetPropertiesPreparer(ctx, accountName, fileSystemName, path, action) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetPropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure sending request") + return + } + + result, err = client.GetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure responding to request") + } + + return +} + +// GetPropertiesPreparer prepares the GetProperties request. +func (client Client) GetPropertiesPreparer(ctx context.Context, accountName string, fileSystemName string, path string, action GetPropertiesAction) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + "path": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "action": autorest.Encode("query", string(action)), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsHead(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + + 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetPropertiesResponder handles the response to the GetProperties request. The method always +// closes the http.Response Body. +func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResponse, err error) { + result = GetPropertiesResponse{} + if resp != nil && resp.Header != nil { + + resourceTypeRaw := resp.Header.Get("x-ms-resource-type") + var resourceType PathResource + if resourceTypeRaw != "" { + resourceType, err = parsePathResource(resourceTypeRaw) + if err != nil { + return GetPropertiesResponse{}, err + } + result.ResourceType = resourceType + } + result.ETag = resp.Header.Get("ETag") + + if lastModifiedRaw := resp.Header.Get("Last-Modified"); lastModifiedRaw != "" { + lastModified, err := time.Parse(time.RFC1123, lastModifiedRaw) + if err != nil { + return GetPropertiesResponse{}, err + } + result.LastModified = lastModified + } + + result.Owner = resp.Header.Get("x-ms-owner") + result.Group = resp.Header.Get("x-ms-group") + result.ACL = resp.Header.Get("x-ms-acl") + } + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return result, err +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go new file mode 100644 index 000000000000..7c0d677647d0 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go @@ -0,0 +1,116 @@ +package paths + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type SetAccessControlInput struct { + Owner *string + Group *string + ACL *string + + // Optional - A date and time value. + // Specify this header to perform the operation only if the resource has been modified since the specified date and time. + IfModifiedSince *string + + // Optional - A date and time value. + // Specify this header to perform the operation only if the resource has not been modified since the specified date and time. + IfUnmodifiedSince *string +} + +// SetProperties sets the access control properties for a Data Lake Store Gen2 Path within a Storage Account File System +func (client Client) SetAccessControl(ctx context.Context, accountName string, fileSystemName string, path string, input SetAccessControlInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("datalakestore.Client", "SetAccessControl", "`accountName` cannot be an empty string.") + } + if fileSystemName == "" { + return result, validation.NewError("datalakestore.Client", "SetAccessControl", "`fileSystemName` cannot be an empty string.") + } + + req, err := client.SetAccessControlPreparer(ctx, accountName, fileSystemName, path, input) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetAccessControl", nil, "Failure preparing request") + return + } + + resp, err := client.SetAccessControlSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetAccessControl", resp, "Failure sending request") + return + } + + result, err = client.SetAccessControlResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetAccessControl", resp, "Failure responding to request") + } + + return +} + +// SetAccessControlPreparer prepares the SetAccessControl request. +func (client Client) SetAccessControlPreparer(ctx context.Context, accountName string, fileSystemName string, path string, input SetAccessControlInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "fileSystemName": autorest.Encode("path", fileSystemName), + "path": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "action": autorest.Encode("query", "setAccessControl"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if input.Owner != nil { + headers["x-ms-owner"] = *input.Owner + } + if input.Group != nil { + headers["x-ms-group"] = *input.Group + } + if input.ACL != nil { + headers["x-ms-acl"] = *input.ACL + } + + if input.IfModifiedSince != nil { + headers["If-Modified-Since"] = *input.IfModifiedSince + } + if input.IfUnmodifiedSince != nil { + headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince + } + + preparer := autorest.CreatePreparer( + autorest.AsPatch(), + autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetAccessControlSender sends the SetAccessControl request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetAccessControlSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetAccessControlResponder handles the response to the SetAccessControl request. The method always +// closes the http.Response Body. +func (client Client) SetAccessControlResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go new file mode 100644 index 000000000000..c32841877067 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go @@ -0,0 +1,57 @@ +package paths + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Data Lake Storage FileSystem +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, fileSystemName, path string) string { + domain := endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s/%s", domain, fileSystemName, path) +} + +type ResourceID struct { + AccountName string + FileSystemName string + Path string +} + +// ParseResourceID parses the specified Resource ID and returns an object +// which can be used to interact with the Data Lake Storage FileSystem API's +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.dfs.core.windows.net/Bar + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + fileSystemAndPath := strings.TrimPrefix(uri.Path, "/") + separatorIndex := strings.Index(fileSystemAndPath, "/") + var fileSystem, path string + if separatorIndex < 0 { + fileSystem = fileSystemAndPath + path = "" + } else { + fileSystem = fileSystemAndPath[0:separatorIndex] + path = fileSystemAndPath[separatorIndex+1:] + } + return &ResourceID{ + AccountName: *accountName, + FileSystemName: fileSystem, + Path: path, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go new file mode 100644 index 000000000000..3ca5674ec31e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go @@ -0,0 +1,14 @@ +package paths + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md new file mode 100644 index 000000000000..25474c8bc44d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md @@ -0,0 +1,48 @@ +## File Storage Directories SDK for API version 2020-08-04 + +This package allows you to interact with the Directories File Storage API + +### Supported Authorizers + +* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) +* SharedKeyLite (Blob, File & Queue) + +### Limitations + +* At this time the headers `x-ms-file-permission` and `x-ms-file-attributes` are hard-coded (to `inherit` and `None`, respectively). + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + shareName := "myshare" + directoryName := "myfiles" + + storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) + directoriesClient := directories.New() + directoriesClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + metadata := map[string]string{ + "hello": "world", + } + if _, err := directoriesClient.Create(ctx, accountName, shareName, directoryName, metadata); err != nil { + return fmt.Errorf("Error creating Directory: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go new file mode 100644 index 000000000000..2699e668022d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go @@ -0,0 +1,16 @@ +package directories + +import ( + "context" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageDirectory interface { + Delete(ctx context.Context, accountName, shareName, path string) (result autorest.Response, err error) + GetMetaData(ctx context.Context, accountName, shareName, path string) (result GetMetaDataResult, err error) + SetMetaData(ctx context.Context, accountName, shareName, path string, metaData map[string]string) (result autorest.Response, err error) + Create(ctx context.Context, accountName, shareName, path string, input CreateDirectoryInput) (result autorest.Response, err error) + GetResourceID(accountName, shareName, directoryName string) string + Get(ctx context.Context, accountName, shareName, path string) (result GetResult, err error) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go new file mode 100644 index 000000000000..bf2d315a524d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go @@ -0,0 +1,25 @@ +package directories + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for File Storage Shares. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go new file mode 100644 index 000000000000..37298319be85 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go @@ -0,0 +1,131 @@ +package directories + +import ( + "context" + "fmt" + "net/http" + "strings" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type CreateDirectoryInput struct { + // The time at which this file was created at - if omitted, this'll be set to "now" + // This maps to the `x-ms-file-creation-time` field. + // ... Yes I know it says File not Directory, I didn't design the API. + CreatedAt *time.Time + + // The time at which this file was last modified - if omitted, this'll be set to "now" + // This maps to the `x-ms-file-last-write-time` field. + // ... Yes I know it says File not Directory, I didn't design the API. + LastModified *time.Time + + // MetaData is a mapping of key value pairs which should be assigned to this directory + MetaData map[string]string +} + +// Create creates a new directory under the specified share or parent directory. +func (client Client) Create(ctx context.Context, accountName, shareName, path string, input CreateDirectoryInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("directories.Client", "Create", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("directories.Client", "Create", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("directories.Client", "Create", "`shareName` must be a lower-cased string.") + } + if path == "" { + return result, validation.NewError("directories.Client", "Create", "`path` cannot be an empty string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("directories.Client", "Create", fmt.Sprintf("`metadata` is not valid: %s.", err)) + } + + req, err := client.CreatePreparer(ctx, accountName, shareName, path, input) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "directories.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "Create", resp, "Failure responding to request") + return + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName, shareName, path string, input CreateDirectoryInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "directory"), + } + + var coalesceDate = func(input *time.Time, defaultVal string) string { + if input == nil { + return defaultVal + } + + return input.Format(time.RFC1123) + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + + // ... Yes I know these say File not Directory, I didn't design the API. + "x-ms-file-permission": "inherit", // TODO: expose this in future + "x-ms-file-attributes": "None", // TODO: expose this in future + "x-ms-file-creation-time": coalesceDate(input.CreatedAt, "now"), + "x-ms-file-last-write-time": coalesceDate(input.LastModified, "now"), + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go new file mode 100644 index 000000000000..9443c2592983 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go @@ -0,0 +1,95 @@ +package directories + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete removes the specified empty directory +// Note that the directory must be empty before it can be deleted. +func (client Client) Delete(ctx context.Context, accountName, shareName, path string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("directories.Client", "Delete", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("directories.Client", "Delete", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("directories.Client", "Delete", "`shareName` must be a lower-cased string.") + } + if path == "" { + return result, validation.NewError("directories.Client", "Delete", "`path` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, shareName, path) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "directories.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName, shareName, path string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "directory"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go new file mode 100644 index 000000000000..817d680b3fca --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go @@ -0,0 +1,112 @@ +package directories + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetResult struct { + autorest.Response + + // A set of name-value pairs that contain metadata for the directory. + MetaData map[string]string + + // The value of this header is set to true if the directory metadata is completely + // encrypted using the specified algorithm. Otherwise, the value is set to false. + DirectoryMetaDataEncrypted bool +} + +// Get returns all system properties for the specified directory, +// and can also be used to check the existence of a directory. +func (client Client) Get(ctx context.Context, accountName, shareName, path string) (result GetResult, err error) { + if accountName == "" { + return result, validation.NewError("directories.Client", "Get", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("directories.Client", "Get", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("directories.Client", "Get", "`shareName` must be a lower-cased string.") + } + if path == "" { + return result, validation.NewError("directories.Client", "Get", "`path` cannot be an empty string.") + } + + req, err := client.GetPreparer(ctx, accountName, shareName, path) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "directories.Client", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "Get", resp, "Failure responding to request") + return + } + + return +} + +// GetPreparer prepares the Get request. +func (client Client) GetPreparer(ctx context.Context, accountName, shareName, path string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "directory"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) GetSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client Client) GetResponder(resp *http.Response) (result GetResult, err error) { + if resp != nil && resp.Header != nil { + result.MetaData = metadata.ParseFromHeaders(resp.Header) + result.DirectoryMetaDataEncrypted = strings.EqualFold(resp.Header.Get("x-ms-server-encrypted"), "true") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go new file mode 100644 index 000000000000..173716de7400 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go @@ -0,0 +1,106 @@ +package directories + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetMetaDataResult struct { + autorest.Response + + MetaData map[string]string +} + +// GetMetaData returns all user-defined metadata for the specified directory +func (client Client) GetMetaData(ctx context.Context, accountName, shareName, path string) (result GetMetaDataResult, err error) { + if accountName == "" { + return result, validation.NewError("directories.Client", "GetMetaData", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("directories.Client", "GetMetaData", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("directories.Client", "GetMetaData", "`shareName` must be a lower-cased string.") + } + if path == "" { + return result, validation.NewError("directories.Client", "GetMetaData", "`path` cannot be an empty string.") + } + + req, err := client.GetMetaDataPreparer(ctx, accountName, shareName, path) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "GetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.GetMetaDataSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "directories.Client", "GetMetaData", resp, "Failure sending request") + return + } + + result, err = client.GetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "GetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// GetMetaDataPreparer prepares the GetMetaData request. +func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, shareName, path string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "directory"), + "comp": autorest.Encode("query", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetMetaDataSender sends the GetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetMetaDataResponder handles the response to the GetMetaData request. The method always +// closes the http.Response Body. +func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { + if resp != nil && resp.Header != nil { + result.MetaData = metadata.ParseFromHeaders(resp.Header) + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go new file mode 100644 index 000000000000..cb133127da00 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go @@ -0,0 +1,102 @@ +package directories + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +// SetMetaData updates user defined metadata for the specified directory +func (client Client) SetMetaData(ctx context.Context, accountName, shareName, path string, metaData map[string]string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("directories.Client", "SetMetaData", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("directories.Client", "SetMetaData", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("directories.Client", "SetMetaData", "`shareName` must be a lower-cased string.") + } + if path == "" { + return result, validation.NewError("directories.Client", "SetMetaData", "`path` cannot be an empty string.") + } + if err := metadata.Validate(metaData); err != nil { + return result, validation.NewError("directories.Client", "SetMetaData", fmt.Sprintf("`metaData` is not valid: %s.", err)) + } + + req, err := client.SetMetaDataPreparer(ctx, accountName, shareName, path, metaData) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "SetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.SetMetaDataSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "directories.Client", "SetMetaData", resp, "Failure sending request") + return + } + + result, err = client.SetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "directories.Client", "SetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// SetMetaDataPreparer prepares the SetMetaData request. +func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, shareName, path string, metaData map[string]string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "directory"), + "comp": autorest.Encode("query", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = metadata.SetIntoHeaders(headers, metaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetMetaDataSender sends the SetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetMetaDataResponder handles the response to the SetMetaData request. The method always +// closes the http.Response Body. +func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go new file mode 100644 index 000000000000..712ed3a00c39 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go @@ -0,0 +1,56 @@ +package directories + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Directory +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, shareName, directoryName string) string { + domain := endpoints.GetFileEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s/%s", domain, shareName, directoryName) +} + +type ResourceID struct { + AccountName string + DirectoryName string + ShareName string +} + +// ParseResourceID parses the Resource ID into an Object +// which can be used to interact with the Directory within the File Share +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.file.core.windows.net/Bar/Folder + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + path := strings.TrimPrefix(uri.Path, "/") + segments := strings.Split(path, "/") + if len(segments) == 0 { + return nil, fmt.Errorf("Expected the path to contain segments but got none") + } + + shareName := segments[0] + directoryName := strings.TrimPrefix(path, shareName) + directoryName = strings.TrimPrefix(directoryName, "/") + return &ResourceID{ + AccountName: *accountName, + ShareName: shareName, + DirectoryName: directoryName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go new file mode 100644 index 000000000000..8446be29ebb2 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go @@ -0,0 +1,14 @@ +package directories + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md new file mode 100644 index 000000000000..6ce6bbb13f96 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md @@ -0,0 +1,47 @@ +## File Storage Files SDK for API version 2020-08-04 + +This package allows you to interact with the Files File Storage API + +### Supported Authorizers + +* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) +* SharedKeyLite (Blob, File & Queue) + +### Limitations + +* At this time the headers `x-ms-file-permission` and `x-ms-file-attributes` are hard-coded (to `inherit` and `None`, respectively). + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + shareName := "myshare" + directoryName := "myfiles" + fileName := "example.txt" + + storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) + filesClient := files.New() + filesClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + input := files.CreateInput{} + if _, err := filesClient.Create(ctx, accountName, shareName, directoryName, fileName, input); err != nil { + return fmt.Errorf("Error creating File: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go new file mode 100644 index 000000000000..96a0491e70da --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go @@ -0,0 +1,28 @@ +package files + +import ( + "context" + "os" + "time" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageFile interface { + PutByteRange(ctx context.Context, accountName, shareName, path, fileName string, input PutByteRangeInput) (result autorest.Response, err error) + GetByteRange(ctx context.Context, accountName, shareName, path, fileName string, input GetByteRangeInput) (result GetByteRangeResult, err error) + ClearByteRange(ctx context.Context, accountName, shareName, path, fileName string, input ClearByteRangeInput) (result autorest.Response, err error) + SetProperties(ctx context.Context, accountName, shareName, path, fileName string, input SetPropertiesInput) (result autorest.Response, err error) + PutFile(ctx context.Context, accountName, shareName, path, fileName string, file *os.File, parallelism int) error + Copy(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput) (result CopyResult, err error) + SetMetaData(ctx context.Context, accountName, shareName, path, fileName string, metaData map[string]string) (result autorest.Response, err error) + GetMetaData(ctx context.Context, accountName, shareName, path, fileName string) (result GetMetaDataResult, err error) + AbortCopy(ctx context.Context, accountName, shareName, path, fileName, copyID string) (result autorest.Response, err error) + GetFile(ctx context.Context, accountName, shareName, path, fileName string, parallelism int) (result autorest.Response, outputBytes []byte, err error) + GetResourceID(accountName, shareName, directoryName, filePath string) string + ListRanges(ctx context.Context, accountName, shareName, path, fileName string) (result ListRangesResult, err error) + GetProperties(ctx context.Context, accountName, shareName, path, fileName string) (result GetResult, err error) + Delete(ctx context.Context, accountName, shareName, path, fileName string) (result autorest.Response, err error) + Create(ctx context.Context, accountName, shareName, path, fileName string, input CreateInput) (result autorest.Response, err error) + CopyAndWait(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput, pollDuration time.Duration) (result CopyResult, err error) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go new file mode 100644 index 000000000000..ecca81586b5a --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go @@ -0,0 +1,25 @@ +package files + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for File Storage Shares. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go new file mode 100644 index 000000000000..31768b3d52b7 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go @@ -0,0 +1,132 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type CopyInput struct { + // Specifies the URL of the source file or blob, up to 2 KB in length. + // + // To copy a file to another file within the same storage account, you may use Shared Key to authenticate + // the source file. If you are copying a file from another storage account, or if you are copying a blob from + // the same storage account or another storage account, then you must authenticate the source file or blob using a + // shared access signature. If the source is a public blob, no authentication is required to perform the copy + // operation. A file in a share snapshot can also be specified as a copy source. + CopySource string + + MetaData map[string]string +} + +type CopyResult struct { + autorest.Response + + // The CopyID, which can be passed to AbortCopy to abort the copy. + CopyID string + + // Either `success` or `pending` + CopySuccess string +} + +// Copy copies a blob or file to a destination file within the storage account asynchronously. +func (client Client) Copy(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput) (result CopyResult, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "Copy", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "Copy", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "Copy", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "Copy", "`fileName` cannot be an empty string.") + } + if input.CopySource == "" { + return result, validation.NewError("files.Client", "Copy", "`input.CopySource` cannot be an empty string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("files.Client", "Copy", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.CopyPreparer(ctx, accountName, shareName, path, fileName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "Copy", nil, "Failure preparing request") + return + } + + resp, err := client.CopySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "Copy", resp, "Failure sending request") + return + } + + result, err = client.CopyResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "Copy", resp, "Failure responding to request") + return + } + + return +} + +// CopyPreparer prepares the Copy request. +func (client Client) CopyPreparer(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-copy-source": input.CopySource, + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CopySender sends the Copy request. The method will close the +// http.Response Body if it receives an error. +func (client Client) CopySender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CopyResponder handles the response to the Copy request. The method always +// closes the http.Response Body. +func (client Client) CopyResponder(resp *http.Response) (result CopyResult, err error) { + if resp != nil && resp.Header != nil { + result.CopyID = resp.Header.Get("x-ms-copy-id") + result.CopySuccess = resp.Header.Get("x-ms-copy-status") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go new file mode 100644 index 000000000000..2f0913185888 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go @@ -0,0 +1,104 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// AbortCopy aborts a pending Copy File operation, and leaves a destination file with zero length and full metadata +func (client Client) AbortCopy(ctx context.Context, accountName, shareName, path, fileName, copyID string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "AbortCopy", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "AbortCopy", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "AbortCopy", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "AbortCopy", "`fileName` cannot be an empty string.") + } + if copyID == "" { + return result, validation.NewError("files.Client", "AbortCopy", "`copyID` cannot be an empty string.") + } + + req, err := client.AbortCopyPreparer(ctx, accountName, shareName, path, fileName, copyID) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "AbortCopy", nil, "Failure preparing request") + return + } + + resp, err := client.AbortCopySender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "AbortCopy", resp, "Failure sending request") + return + } + + result, err = client.AbortCopyResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "AbortCopy", resp, "Failure responding to request") + return + } + + return +} + +// AbortCopyPreparer prepares the AbortCopy request. +func (client Client) AbortCopyPreparer(ctx context.Context, accountName, shareName, path, fileName, copyID string) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "copy"), + "copyid": autorest.Encode("query", copyID), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-copy-action": "abort", + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// AbortCopySender sends the AbortCopy request. The method will close the +// http.Response Body if it receives an error. +func (client Client) AbortCopySender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// AbortCopyResponder handles the response to the AbortCopy request. The method always +// closes the http.Response Body. +func (client Client) AbortCopyResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go new file mode 100644 index 000000000000..e6a646b1017b --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go @@ -0,0 +1,55 @@ +package files + +import ( + "context" + "fmt" + "strings" + "time" + + "github.com/Azure/go-autorest/autorest" +) + +type CopyAndWaitResult struct { + autorest.Response + + CopyID string +} + +const DefaultCopyPollDuration = 15 * time.Second + +// CopyAndWait is a convenience method which doesn't exist in the API, which copies the file and then waits for the copy to complete +func (client Client) CopyAndWait(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput, pollDuration time.Duration) (result CopyResult, err error) { + copy, e := client.Copy(ctx, accountName, shareName, path, fileName, input) + if err != nil { + result.Response = copy.Response + err = fmt.Errorf("Error copying: %s", e) + return + } + + result.CopyID = copy.CopyID + + // since the API doesn't return a LRO, this is a hack which also polls every 10s, but should be sufficient + for true { + props, e := client.GetProperties(ctx, accountName, shareName, path, fileName) + if e != nil { + result.Response = copy.Response + err = fmt.Errorf("Error waiting for copy: %s", e) + return + } + + switch strings.ToLower(props.CopyStatus) { + case "pending": + time.Sleep(pollDuration) + continue + + case "success": + return + + default: + err = fmt.Errorf("Unexpected CopyState %q", e) + return + } + } + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go new file mode 100644 index 000000000000..d2b4ff358120 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go @@ -0,0 +1,169 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type CreateInput struct { + // This header specifies the maximum size for the file, up to 1 TiB. + ContentLength int64 + + // The MIME content type of the file + // If not specified, the default type is application/octet-stream. + ContentType *string + + // Specifies which content encodings have been applied to the file. + // This value is returned to the client when the Get File operation is performed + // on the file resource and can be used to decode file content. + ContentEncoding *string + + // Specifies the natural languages used by this resource. + ContentLanguage *string + + // The File service stores this value but does not use or modify it. + CacheControl *string + + // Sets the file's MD5 hash. + ContentMD5 *string + + // Sets the file’s Content-Disposition header. + ContentDisposition *string + + // The time at which this file was created at - if omitted, this'll be set to "now" + // This maps to the `x-ms-file-creation-time` field. + CreatedAt *time.Time + + // The time at which this file was last modified - if omitted, this'll be set to "now" + // This maps to the `x-ms-file-last-write-time` field. + LastModified *time.Time + + // MetaData is a mapping of key value pairs which should be assigned to this file + MetaData map[string]string +} + +// Create creates a new file or replaces a file. +func (client Client) Create(ctx context.Context, accountName, shareName, path, fileName string, input CreateInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "Create", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "Create", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "Create", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "Create", "`fileName` cannot be an empty string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("files.Client", "Create", "`input.MetaData` cannot be an empty string.") + } + + req, err := client.CreatePreparer(ctx, accountName, shareName, path, fileName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "Create", resp, "Failure responding to request") + return + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName, shareName, path, fileName string, input CreateInput) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + var coalesceDate = func(input *time.Time, defaultVal string) string { + if input == nil { + return defaultVal + } + + return input.Format(time.RFC1123) + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-content-length": input.ContentLength, + "x-ms-type": "file", + + "x-ms-file-permission": "inherit", // TODO: expose this in future + "x-ms-file-attributes": "None", // TODO: expose this in future + "x-ms-file-creation-time": coalesceDate(input.CreatedAt, "now"), + "x-ms-file-last-write-time": coalesceDate(input.LastModified, "now"), + } + + if input.ContentDisposition != nil { + headers["x-ms-content-disposition"] = *input.ContentDisposition + } + + if input.ContentEncoding != nil { + headers["x-ms-content-encoding"] = *input.ContentEncoding + } + + if input.ContentMD5 != nil { + headers["x-ms-content-md5"] = *input.ContentMD5 + } + + if input.ContentType != nil { + headers["x-ms-content-type"] = *input.ContentType + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go new file mode 100644 index 000000000000..5debd767d1fd --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go @@ -0,0 +1,94 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete immediately deletes the file from the File Share. +func (client Client) Delete(ctx context.Context, accountName, shareName, path, fileName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "Delete", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "Delete", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "Delete", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "Delete", "`fileName` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, shareName, path, fileName) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go new file mode 100644 index 000000000000..fd62f90aec8f --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go @@ -0,0 +1,111 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetMetaDataResult struct { + autorest.Response + + MetaData map[string]string +} + +// GetMetaData returns the MetaData for the specified File. +func (client Client) GetMetaData(ctx context.Context, accountName, shareName, path, fileName string) (result GetMetaDataResult, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "GetMetaData", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "GetMetaData", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "GetMetaData", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "GetMetaData", "`fileName` cannot be an empty string.") + } + + req, err := client.GetMetaDataPreparer(ctx, accountName, shareName, path, fileName) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "GetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.GetMetaDataSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "GetMetaData", resp, "Failure sending request") + return + } + + result, err = client.GetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "GetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// GetMetaDataPreparer prepares the GetMetaData request. +func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetMetaDataSender sends the GetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetMetaDataResponder handles the response to the GetMetaData request. The method always +// closes the http.Response Body. +func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { + if resp != nil && resp.Header != nil { + result.MetaData = metadata.ParseFromHeaders(resp.Header) + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + //metadata.ByParsingFromHeaders(&result.MetaData), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go new file mode 100644 index 000000000000..41e3ffcb8ff9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go @@ -0,0 +1,105 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +// SetMetaData updates the specified File to have the specified MetaData. +func (client Client) SetMetaData(ctx context.Context, accountName, shareName, path, fileName string, metaData map[string]string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "SetMetaData", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "SetMetaData", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "SetMetaData", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "SetMetaData", "`fileName` cannot be an empty string.") + } + if err := metadata.Validate(metaData); err != nil { + return result, validation.NewError("files.Client", "SetMetaData", fmt.Sprintf("`metaData` is not valid: %s.", err)) + } + + req, err := client.SetMetaDataPreparer(ctx, accountName, shareName, path, fileName, metaData) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "SetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.SetMetaDataSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "SetMetaData", resp, "Failure sending request") + return + } + + result, err = client.SetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "SetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// SetMetaDataPreparer prepares the SetMetaData request. +func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, shareName, path, fileName string, metaData map[string]string) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = metadata.SetIntoHeaders(headers, metaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetMetaDataSender sends the SetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetMetaDataResponder handles the response to the SetMetaData request. The method always +// closes the http.Response Body. +func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go new file mode 100644 index 000000000000..c6a0c399d2d7 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go @@ -0,0 +1,144 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strconv" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetResult struct { + autorest.Response + + CacheControl string + ContentDisposition string + ContentEncoding string + ContentLanguage string + ContentLength *int64 + ContentMD5 string + ContentType string + CopyID string + CopyStatus string + CopySource string + CopyProgress string + CopyStatusDescription string + CopyCompletionTime string + Encrypted bool + + MetaData map[string]string +} + +// GetProperties returns the Properties for the specified file +func (client Client) GetProperties(ctx context.Context, accountName, shareName, path, fileName string) (result GetResult, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "GetProperties", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "GetProperties", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "GetProperties", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "GetProperties", "`fileName` cannot be an empty string.") + } + + req, err := client.GetPropertiesPreparer(ctx, accountName, shareName, path, fileName) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "GetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetPropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "GetProperties", resp, "Failure sending request") + return + } + + result, err = client.GetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "GetProperties", resp, "Failure responding to request") + return + } + + return +} + +// GetPropertiesPreparer prepares the GetProperties request. +func (client Client) GetPropertiesPreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsHead(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetPropertiesResponder handles the response to the GetProperties request. The method always +// closes the http.Response Body. +func (client Client) GetPropertiesResponder(resp *http.Response) (result GetResult, err error) { + if resp != nil && resp.Header != nil { + result.CacheControl = resp.Header.Get("Cache-Control") + result.ContentDisposition = resp.Header.Get("Content-Disposition") + result.ContentEncoding = resp.Header.Get("Content-Encoding") + result.ContentLanguage = resp.Header.Get("Content-Language") + result.ContentMD5 = resp.Header.Get("x-ms-content-md5") + result.ContentType = resp.Header.Get("Content-Type") + result.CopyID = resp.Header.Get("x-ms-copy-id") + result.CopyProgress = resp.Header.Get("x-ms-copy-progress") + result.CopySource = resp.Header.Get("x-ms-copy-source") + result.CopyStatus = resp.Header.Get("x-ms-copy-status") + result.CopyStatusDescription = resp.Header.Get("x-ms-copy-status-description") + result.CopyCompletionTime = resp.Header.Get("x-ms-copy-completion-time") + result.Encrypted = strings.EqualFold(resp.Header.Get("x-ms-server-encrypted"), "true") + result.MetaData = metadata.ParseFromHeaders(resp.Header) + + contentLengthRaw := resp.Header.Get("Content-Length") + if contentLengthRaw != "" { + contentLength, err := strconv.Atoi(contentLengthRaw) + if err != nil { + return result, fmt.Errorf("Error parsing %q for Content-Length as an integer: %s", contentLengthRaw, err) + } + contentLengthI64 := int64(contentLength) + result.ContentLength = &contentLengthI64 + } + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go new file mode 100644 index 000000000000..521b1bba7be7 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go @@ -0,0 +1,186 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type SetPropertiesInput struct { + // Resizes a file to the specified size. + // If the specified byte value is less than the current size of the file, + // then all ranges above the specified byte value are cleared. + ContentLength int64 + + // Modifies the cache control string for the file. + // If this property is not specified on the request, then the property will be cleared for the file. + // Subsequent calls to Get File Properties will not return this property, + // unless it is explicitly set on the file again. + ContentControl *string + + // Sets the file’s Content-Disposition header. + // If this property is not specified on the request, then the property will be cleared for the file. + // Subsequent calls to Get File Properties will not return this property, + // unless it is explicitly set on the file again. + ContentDisposition *string + + // Sets the file's content encoding. + // If this property is not specified on the request, then the property will be cleared for the file. + // Subsequent calls to Get File Properties will not return this property, + // unless it is explicitly set on the file again. + ContentEncoding *string + + // Sets the file's content language. + // If this property is not specified on the request, then the property will be cleared for the file. + // Subsequent calls to Get File Properties will not return this property, + // unless it is explicitly set on the file again. + ContentLanguage *string + + // Sets the file's MD5 hash. + // If this property is not specified on the request, then the property will be cleared for the file. + // Subsequent calls to Get File Properties will not return this property, + // unless it is explicitly set on the file again. + ContentMD5 *string + + // Sets the file's content type. + // If this property is not specified on the request, then the property will be cleared for the file. + // Subsequent calls to Get File Properties will not return this property, + // unless it is explicitly set on the file again. + ContentType *string + + // The time at which this file was created at - if omitted, this'll be set to "now" + // This maps to the `x-ms-file-creation-time` field. + CreatedAt *time.Time + + // The time at which this file was last modified - if omitted, this'll be set to "now" + // This maps to the `x-ms-file-last-write-time` field. + LastModified *time.Time + + // MetaData is a mapping of key value pairs which should be assigned to this file + MetaData map[string]string +} + +// SetProperties sets the specified properties on the specified File +func (client Client) SetProperties(ctx context.Context, accountName, shareName, path, fileName string, input SetPropertiesInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "SetProperties", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "SetProperties", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "SetProperties", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "SetProperties", "`fileName` cannot be an empty string.") + } + + req, err := client.SetPropertiesPreparer(ctx, accountName, shareName, path, fileName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "SetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.SetPropertiesSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "SetProperties", resp, "Failure sending request") + return + } + + result, err = client.SetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "SetProperties", resp, "Failure responding to request") + return + } + + return +} + +// SetPropertiesPreparer prepares the SetProperties request. +func (client Client) SetPropertiesPreparer(ctx context.Context, accountName, shareName, path, fileName string, input SetPropertiesInput) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + var coalesceDate = func(input *time.Time, defaultVal string) string { + if input == nil { + return defaultVal + } + + return input.Format(time.RFC1123) + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-type": "file", + + "x-ms-content-length": input.ContentLength, + "x-ms-file-permission": "inherit", // TODO: expose this in future + "x-ms-file-attributes": "None", // TODO: expose this in future + "x-ms-file-creation-time": coalesceDate(input.CreatedAt, "now"), + "x-ms-file-last-write-time": coalesceDate(input.LastModified, "now"), + } + + if input.ContentControl != nil { + headers["x-ms-cache-control"] = *input.ContentControl + } + if input.ContentDisposition != nil { + headers["x-ms-content-disposition"] = *input.ContentDisposition + } + if input.ContentEncoding != nil { + headers["x-ms-content-encoding"] = *input.ContentEncoding + } + if input.ContentLanguage != nil { + headers["x-ms-content-language"] = *input.ContentLanguage + } + if input.ContentMD5 != nil { + headers["x-ms-content-md5"] = *input.ContentMD5 + } + if input.ContentType != nil { + headers["x-ms-content-type"] = *input.ContentType + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetPropertiesSender sends the SetProperties request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetPropertiesResponder handles the response to the SetProperties request. The method always +// closes the http.Response Body. +func (client Client) SetPropertiesResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go new file mode 100644 index 000000000000..5d8145fae422 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go @@ -0,0 +1,112 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type ClearByteRangeInput struct { + StartBytes int64 + EndBytes int64 +} + +// ClearByteRange clears the specified Byte Range from within the specified File +func (client Client) ClearByteRange(ctx context.Context, accountName, shareName, path, fileName string, input ClearByteRangeInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "ClearByteRange", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "ClearByteRange", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "ClearByteRange", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "ClearByteRange", "`fileName` cannot be an empty string.") + } + if input.StartBytes < 0 { + return result, validation.NewError("files.Client", "ClearByteRange", "`input.StartBytes` must be greater or equal to 0.") + } + if input.EndBytes <= 0 { + return result, validation.NewError("files.Client", "ClearByteRange", "`input.EndBytes` must be greater than 0.") + } + + req, err := client.ClearByteRangePreparer(ctx, accountName, shareName, path, fileName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "ClearByteRange", nil, "Failure preparing request") + return + } + + resp, err := client.ClearByteRangeSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "ClearByteRange", resp, "Failure sending request") + return + } + + result, err = client.ClearByteRangeResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "ClearByteRange", resp, "Failure responding to request") + return + } + + return +} + +// ClearByteRangePreparer prepares the ClearByteRange request. +func (client Client) ClearByteRangePreparer(ctx context.Context, accountName, shareName, path, fileName string, input ClearByteRangeInput) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "range"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-write": "clear", + "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartBytes, input.EndBytes), + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ClearByteRangeSender sends the ClearByteRange request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ClearByteRangeSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ClearByteRangeResponder handles the response to the ClearByteRange request. The method always +// closes the http.Response Body. +func (client Client) ClearByteRangeResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go new file mode 100644 index 000000000000..733d3f525105 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go @@ -0,0 +1,121 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetByteRangeInput struct { + StartBytes int64 + EndBytes int64 +} + +type GetByteRangeResult struct { + autorest.Response + + Contents []byte +} + +// GetByteRange returns the specified Byte Range from the specified File. +func (client Client) GetByteRange(ctx context.Context, accountName, shareName, path, fileName string, input GetByteRangeInput) (result GetByteRangeResult, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "GetByteRange", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "GetByteRange", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "GetByteRange", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "GetByteRange", "`fileName` cannot be an empty string.") + } + if input.StartBytes < 0 { + return result, validation.NewError("files.Client", "GetByteRange", "`input.StartBytes` must be greater or equal to 0.") + } + if input.EndBytes <= 0 { + return result, validation.NewError("files.Client", "GetByteRange", "`input.EndBytes` must be greater than 0.") + } + expectedBytes := input.EndBytes - input.StartBytes + if expectedBytes < (4 * 1024) { + return result, validation.NewError("files.Client", "GetByteRange", "Requested Byte Range must be at least 4KB.") + } + if expectedBytes > (4 * 1024 * 1024) { + return result, validation.NewError("files.Client", "GetByteRange", "Requested Byte Range must be at most 4MB.") + } + + req, err := client.GetByteRangePreparer(ctx, accountName, shareName, path, fileName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "GetByteRange", nil, "Failure preparing request") + return + } + + resp, err := client.GetByteRangeSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "GetByteRange", resp, "Failure sending request") + return + } + + result, err = client.GetByteRangeResponder(resp, expectedBytes) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "GetByteRange", resp, "Failure responding to request") + return + } + + return +} + +// GetByteRangePreparer prepares the GetByteRange request. +func (client Client) GetByteRangePreparer(ctx context.Context, accountName, shareName, path, fileName string, input GetByteRangeInput) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartBytes, input.EndBytes-1), + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetByteRangeSender sends the GetByteRange request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetByteRangeSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetByteRangeResponder handles the response to the GetByteRange request. The method always +// closes the http.Response Body. +func (client Client) GetByteRangeResponder(resp *http.Response, length int64) (result GetByteRangeResult, err error) { + result.Contents = make([]byte, length) + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusPartialContent), + autorest.ByUnmarshallingBytes(&result.Contents), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go new file mode 100644 index 000000000000..9e5be17f85fc --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go @@ -0,0 +1,128 @@ +package files + +import ( + "context" + "fmt" + "log" + "math" + "runtime" + "sync" + + "github.com/Azure/go-autorest/autorest" +) + +// GetFile is a helper method to download a file by chunking it automatically +func (client Client) GetFile(ctx context.Context, accountName, shareName, path, fileName string, parallelism int) (result autorest.Response, outputBytes []byte, err error) { + + // first look up the file and check out how many bytes it is + file, e := client.GetProperties(ctx, accountName, shareName, path, fileName) + if err != nil { + result = file.Response + err = e + return + } + + if file.ContentLength == nil { + err = fmt.Errorf("Content-Length was nil!") + return + } + + length := int64(*file.ContentLength) + chunkSize := int64(4 * 1024 * 1024) // 4MB + + if chunkSize > length { + chunkSize = length + } + + // then split that up into chunks and retrieve it retrieve it into the 'results' set + chunks := int(math.Ceil(float64(length) / float64(chunkSize))) + workerCount := parallelism * runtime.NumCPU() + if workerCount > chunks { + workerCount = chunks + } + + var waitGroup sync.WaitGroup + waitGroup.Add(workerCount) + + results := make([]*downloadFileChunkResult, chunks) + errors := make(chan error, chunkSize) + + for i := 0; i < chunks; i++ { + go func(i int) { + log.Printf("[DEBUG] Downloading Chunk %d of %d", i+1, chunks) + + dfci := downloadFileChunkInput{ + thisChunk: i, + chunkSize: chunkSize, + fileSize: length, + } + + result, err := client.downloadFileChunk(ctx, accountName, shareName, path, fileName, dfci) + if err != nil { + errors <- err + waitGroup.Done() + return + } + + // if there's no error, we should have bytes, so this is safe + results[i] = result + + waitGroup.Done() + }(i) + } + waitGroup.Wait() + + // TODO: we should switch to hashicorp/multi-error here + if len(errors) > 0 { + err = fmt.Errorf("Error downloading file: %s", <-errors) + return + } + + // then finally put it all together, in order and return it + output := make([]byte, length) + for _, v := range results { + copy(output[v.startBytes:v.endBytes], v.bytes) + } + + outputBytes = output + return +} + +type downloadFileChunkInput struct { + thisChunk int + chunkSize int64 + fileSize int64 +} + +type downloadFileChunkResult struct { + startBytes int64 + endBytes int64 + bytes []byte +} + +func (client Client) downloadFileChunk(ctx context.Context, accountName, shareName, path, fileName string, input downloadFileChunkInput) (*downloadFileChunkResult, error) { + startBytes := input.chunkSize * int64(input.thisChunk) + endBytes := startBytes + input.chunkSize + + // the last chunk may exceed the size of the file + remaining := input.fileSize - startBytes + if input.chunkSize > remaining { + endBytes = startBytes + remaining + } + + getInput := GetByteRangeInput{ + StartBytes: startBytes, + EndBytes: endBytes, + } + result, err := client.GetByteRange(ctx, accountName, shareName, path, fileName, getInput) + if err != nil { + return nil, fmt.Errorf("Error putting bytes: %s", err) + } + + output := downloadFileChunkResult{ + startBytes: startBytes, + endBytes: endBytes, + bytes: result.Contents, + } + return &output, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go new file mode 100644 index 000000000000..20e4d398d590 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go @@ -0,0 +1,127 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type PutByteRangeInput struct { + StartBytes int64 + EndBytes int64 + + // Content is the File Contents for the specified range + // which can be at most 4MB + Content []byte +} + +// PutByteRange puts the specified Byte Range in the specified File. +func (client Client) PutByteRange(ctx context.Context, accountName, shareName, path, fileName string, input PutByteRangeInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "PutByteRange", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "PutByteRange", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "PutByteRange", "`shareName` must be a lower-cased string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "PutByteRange", "`fileName` cannot be an empty string.") + } + if input.StartBytes < 0 { + return result, validation.NewError("files.Client", "PutByteRange", "`input.StartBytes` must be greater or equal to 0.") + } + if input.EndBytes <= 0 { + return result, validation.NewError("files.Client", "PutByteRange", "`input.EndBytes` must be greater than 0.") + } + + expectedBytes := input.EndBytes - input.StartBytes + actualBytes := len(input.Content) + if expectedBytes != int64(actualBytes) { + return result, validation.NewError("files.Client", "PutByteRange", fmt.Sprintf("The specified byte-range (%d) didn't match the content size (%d).", expectedBytes, actualBytes)) + } + + if expectedBytes > (4 * 1024 * 1024) { + return result, validation.NewError("files.Client", "PutByteRange", "Specified Byte Range must be at most 4MB.") + } + + req, err := client.PutByteRangePreparer(ctx, accountName, shareName, path, fileName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "PutByteRange", nil, "Failure preparing request") + return + } + + resp, err := client.PutByteRangeSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "PutByteRange", resp, "Failure sending request") + return + } + + result, err = client.PutByteRangeResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "PutByteRange", resp, "Failure responding to request") + return + } + + return +} + +// PutByteRangePreparer prepares the PutByteRange request. +func (client Client) PutByteRangePreparer(ctx context.Context, accountName, shareName, path, fileName string, input PutByteRangeInput) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "range"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-write": "update", + "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartBytes, input.EndBytes-1), + "Content-Length": int(len(input.Content)), + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters), + autorest.WithBytes(&input.Content)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// PutByteRangeSender sends the PutByteRange request. The method will close the +// http.Response Body if it receives an error. +func (client Client) PutByteRangeSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// PutByteRangeResponder handles the response to the PutByteRange request. The method always +// closes the http.Response Body. +func (client Client) PutByteRangeResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go new file mode 100644 index 000000000000..a39cd377cee8 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go @@ -0,0 +1,107 @@ +package files + +import ( + "context" + "fmt" + "io" + "log" + "math" + "os" + "runtime" + "sync" + + "github.com/Azure/go-autorest/autorest" +) + +// PutFile is a helper method which takes a file, and automatically chunks it up, rather than having to do this yourself +func (client Client) PutFile(ctx context.Context, accountName, shareName, path, fileName string, file *os.File, parallelism int) error { + fileInfo, err := file.Stat() + if err != nil { + return fmt.Errorf("Error loading file info: %s", err) + } + + fileSize := fileInfo.Size() + chunkSize := 4 * 1024 * 1024 // 4MB + if chunkSize > int(fileSize) { + chunkSize = int(fileSize) + } + chunks := int(math.Ceil(float64(fileSize) / float64(chunkSize*1.0))) + + workerCount := parallelism * runtime.NumCPU() + if workerCount > chunks { + workerCount = chunks + } + + var waitGroup sync.WaitGroup + waitGroup.Add(workerCount) + errors := make(chan error, chunkSize) + + for i := 0; i < chunks; i++ { + go func(i int) { + log.Printf("[DEBUG] Chunk %d of %d", i+1, chunks) + + uci := uploadChunkInput{ + thisChunk: i, + chunkSize: chunkSize, + fileSize: fileSize, + } + + _, err := client.uploadChunk(ctx, accountName, shareName, path, fileName, uci, file) + if err != nil { + errors <- err + waitGroup.Done() + return + } + + waitGroup.Done() + return + }(i) + } + waitGroup.Wait() + + // TODO: we should switch to hashicorp/multi-error here + if len(errors) > 0 { + return fmt.Errorf("Error uploading file: %s", <-errors) + } + + return nil +} + +type uploadChunkInput struct { + thisChunk int + chunkSize int + fileSize int64 +} + +func (client Client) uploadChunk(ctx context.Context, accountName, shareName, path, fileName string, input uploadChunkInput, file *os.File) (result autorest.Response, err error) { + startBytes := int64(input.chunkSize * input.thisChunk) + endBytes := startBytes + int64(input.chunkSize) + + // the last size may exceed the size of the file + remaining := input.fileSize - startBytes + if int64(input.chunkSize) > remaining { + endBytes = startBytes + remaining + } + + bytesToRead := int(endBytes) - int(startBytes) + bytes := make([]byte, bytesToRead) + + _, err = file.ReadAt(bytes, startBytes) + if err != nil { + if err != io.EOF { + return result, fmt.Errorf("Error reading bytes: %s", err) + } + } + + putBytesInput := PutByteRangeInput{ + StartBytes: startBytes, + EndBytes: endBytes, + Content: bytes, + } + result, err = client.PutByteRange(ctx, accountName, shareName, path, fileName, putBytesInput) + if err != nil { + return result, fmt.Errorf("Error putting bytes: %s", err) + } + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go new file mode 100644 index 000000000000..ea309f97ddb2 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go @@ -0,0 +1,114 @@ +package files + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type ListRangesResult struct { + autorest.Response + + Ranges []Range `xml:"Range"` +} + +type Range struct { + Start string `xml:"Start"` + End string `xml:"End"` +} + +// ListRanges returns the list of valid ranges for the specified File. +func (client Client) ListRanges(ctx context.Context, accountName, shareName, path, fileName string) (result ListRangesResult, err error) { + if accountName == "" { + return result, validation.NewError("files.Client", "ListRanges", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("files.Client", "ListRanges", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("files.Client", "ListRanges", "`shareName` must be a lower-cased string.") + } + if path == "" { + return result, validation.NewError("files.Client", "ListRanges", "`path` cannot be an empty string.") + } + if fileName == "" { + return result, validation.NewError("files.Client", "ListRanges", "`fileName` cannot be an empty string.") + } + + req, err := client.ListRangesPreparer(ctx, accountName, shareName, path, fileName) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "ListRanges", nil, "Failure preparing request") + return + } + + resp, err := client.ListRangesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "files.Client", "ListRanges", resp, "Failure sending request") + return + } + + result, err = client.ListRangesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "files.Client", "ListRanges", resp, "Failure responding to request") + return + } + + return +} + +// ListRangesPreparer prepares the ListRanges request. +func (client Client) ListRangesPreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { + if path != "" { + path = fmt.Sprintf("%s/", path) + } + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + "directory": autorest.Encode("path", path), + "fileName": autorest.Encode("path", fileName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "rangelist"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), + autorest.WithHeaders(headers), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListRangesSender sends the ListRanges request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ListRangesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ListRangesResponder handles the response to the ListRanges request. The method always +// closes the http.Response Body. +func (client Client) ListRangesResponder(resp *http.Response) (result ListRangesResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go new file mode 100644 index 000000000000..f18e702e81d9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go @@ -0,0 +1,64 @@ +package files + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given File +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, shareName, directoryName, filePath string) string { + domain := endpoints.GetFileEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s/%s/%s", domain, shareName, directoryName, filePath) +} + +type ResourceID struct { + AccountName string + DirectoryName string + FileName string + ShareName string +} + +// ParseResourceID parses the specified Resource ID and returns an object +// which can be used to interact with Files within a Storage Share. +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://account1.file.core.chinacloudapi.cn/share1/directory1/file1.txt + // example: https://account1.file.core.chinacloudapi.cn/share1/directory1/directory2/file1.txt + + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + path := strings.TrimPrefix(uri.Path, "/") + segments := strings.Split(path, "/") + if len(segments) == 0 { + return nil, fmt.Errorf("Expected the path to contain segments but got none") + } + + shareName := segments[0] + fileName := segments[len(segments)-1] + + directoryName := strings.TrimPrefix(path, shareName) + directoryName = strings.TrimPrefix(directoryName, "/") + directoryName = strings.TrimSuffix(directoryName, fileName) + directoryName = strings.TrimSuffix(directoryName, "/") + return &ResourceID{ + AccountName: *accountName, + ShareName: shareName, + DirectoryName: directoryName, + FileName: fileName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go new file mode 100644 index 000000000000..7c8231033703 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go @@ -0,0 +1,14 @@ +package files + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md new file mode 100644 index 000000000000..ecc0f13ae9bb --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md @@ -0,0 +1,43 @@ +## File Storage Shares SDK for API version 2020-08-04 + +This package allows you to interact with the Shares File Storage API + +### Supported Authorizers + +* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) +* SharedKeyLite (Blob, File & Queue) + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + shareName := "myshare" + + storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) + sharesClient := shares.New() + sharesClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + input := shares.CreateInput{ + QuotaInGB: 2, + } + if _, err := sharesClient.Create(ctx, accountName, shareName, input); err != nil { + return fmt.Errorf("Error creating Share: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go new file mode 100644 index 000000000000..ea6ff4c2dd26 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go @@ -0,0 +1,98 @@ +package shares + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetACLResult struct { + autorest.Response + + SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` +} + +// GetACL get the Access Control List for the specified Storage Share +func (client Client) GetACL(ctx context.Context, accountName, shareName string) (result GetACLResult, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "GetACL", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "GetACL", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "GetACL", "`shareName` must be a lower-cased string.") + } + + req, err := client.GetACLPreparer(ctx, accountName, shareName) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetACL", nil, "Failure preparing request") + return + } + + resp, err := client.GetACLSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "GetACL", resp, "Failure sending request") + return + } + + result, err = client.GetACLResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetACL", resp, "Failure responding to request") + return + } + + return +} + +// GetACLPreparer prepares the GetACL request. +func (client Client) GetACLPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + "comp": autorest.Encode("query", "acl"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetACLSender sends the GetACL request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetACLSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetACLResponder handles the response to the GetACL request. The method always +// closes the http.Response Body. +func (client Client) GetACLResponder(resp *http.Response) (result GetACLResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go new file mode 100644 index 000000000000..18d1788a2ee4 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go @@ -0,0 +1,103 @@ +package shares + +import ( + "context" + "encoding/xml" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type setAcl struct { + SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` + + XMLName xml.Name `xml:"SignedIdentifiers"` +} + +// SetACL sets the specified Access Control List on the specified Storage Share +func (client Client) SetACL(ctx context.Context, accountName, shareName string, acls []SignedIdentifier) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "SetACL", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "SetACL", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "SetACL", "`shareName` must be a lower-cased string.") + } + + req, err := client.SetACLPreparer(ctx, accountName, shareName, acls) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "SetACL", nil, "Failure preparing request") + return + } + + resp, err := client.SetACLSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "SetACL", resp, "Failure sending request") + return + } + + result, err = client.SetACLResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "SetACL", resp, "Failure responding to request") + return + } + + return +} + +// SetACLPreparer prepares the SetACL request. +func (client Client) SetACLPreparer(ctx context.Context, accountName, shareName string, acls []SignedIdentifier) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + "comp": autorest.Encode("query", "acl"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + input := setAcl{ + SignedIdentifiers: acls, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers), + autorest.WithXML(&input)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetACLSender sends the SetACL request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetACLSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetACLResponder handles the response to the SetACL request. The method always +// closes the http.Response Body. +func (client Client) SetACLResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go new file mode 100644 index 000000000000..62389b4c0a98 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go @@ -0,0 +1,24 @@ +package shares + +import ( + "context" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageShare interface { + SetACL(ctx context.Context, accountName, shareName string, acls []SignedIdentifier) (result autorest.Response, err error) + GetSnapshot(ctx context.Context, accountName, shareName, snapshotShare string) (result GetSnapshotPropertiesResult, err error) + GetStats(ctx context.Context, accountName, shareName string) (result GetStatsResult, err error) + GetACL(ctx context.Context, accountName, shareName string) (result GetACLResult, err error) + SetMetaData(ctx context.Context, accountName, shareName string, metaData map[string]string) (result autorest.Response, err error) + GetMetaData(ctx context.Context, accountName, shareName string) (result GetMetaDataResult, err error) + SetProperties(ctx context.Context, accountName, shareName string, newQuotaGB int) (result autorest.Response, err error) + DeleteSnapshot(ctx context.Context, accountName, shareName string, shareSnapshot string) (result autorest.Response, err error) + CreateSnapshot(ctx context.Context, accountName, shareName string, input CreateSnapshotInput) (result CreateSnapshotResult, err error) + GetResourceID(accountName, shareName string) string + GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, shareName string) string + GetProperties(ctx context.Context, accountName, shareName string) (result GetPropertiesResult, err error) + Delete(ctx context.Context, accountName, shareName string, deleteSnapshots bool) (result autorest.Response, err error) + Create(ctx context.Context, accountName, shareName string, input CreateInput) (result autorest.Response, err error) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go new file mode 100644 index 000000000000..4f3a6f9f99d0 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go @@ -0,0 +1,25 @@ +package shares + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for File Storage Shares. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go new file mode 100644 index 000000000000..0124e81ec128 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go @@ -0,0 +1,109 @@ +package shares + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type CreateInput struct { + // Specifies the maximum size of the share, in gigabytes. + // Must be greater than 0, and less than or equal to 5TB (5120). + QuotaInGB int + + MetaData map[string]string +} + +// Create creates the specified Storage Share within the specified Storage Account +func (client Client) Create(ctx context.Context, accountName, shareName string, input CreateInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "Create", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "Create", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "Create", "`shareName` must be a lower-cased string.") + } + if input.QuotaInGB <= 0 || input.QuotaInGB > 102400 { + return result, validation.NewError("shares.Client", "Create", "`input.QuotaInGB` must be greater than 0, and less than/equal to 100TB (102400 GB)") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("shares.Client", "Create", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.CreatePreparer(ctx, accountName, shareName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "Create", resp, "Failure responding to request") + return + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName, shareName string, input CreateInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "share"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-share-quota": input.QuotaInGB, + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go new file mode 100644 index 000000000000..70ef985d23bb --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go @@ -0,0 +1,94 @@ +package shares + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete deletes the specified Storage Share from within a Storage Account +func (client Client) Delete(ctx context.Context, accountName, shareName string, deleteSnapshots bool) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "Delete", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "Delete", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "Delete", "`shareName` must be a lower-cased string.") + } + + req, err := client.DeletePreparer(ctx, accountName, shareName, deleteSnapshots) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName, shareName string, deleteSnapshots bool) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "share"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + if deleteSnapshots { + headers["x-ms-delete-snapshots"] = "include" + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go new file mode 100644 index 000000000000..9fa4d9f07ed8 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go @@ -0,0 +1,102 @@ +package shares + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetMetaDataResult struct { + autorest.Response + + MetaData map[string]string +} + +// GetMetaData returns the MetaData associated with the specified Storage Share +func (client Client) GetMetaData(ctx context.Context, accountName, shareName string) (result GetMetaDataResult, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "GetMetaData", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "GetMetaData", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "GetMetaData", "`shareName` must be a lower-cased string.") + } + + req, err := client.GetMetaDataPreparer(ctx, accountName, shareName) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.GetMetaDataSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "GetMetaData", resp, "Failure sending request") + return + } + + result, err = client.GetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// GetMetaDataPreparer prepares the GetMetaData request. +func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + "comp": autorest.Encode("query", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetMetaDataSender sends the GetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetMetaDataResponder handles the response to the GetMetaData request. The method always +// closes the http.Response Body. +func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { + if resp.Header != nil { + result.MetaData = metadata.ParseFromHeaders(resp.Header) + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go new file mode 100644 index 000000000000..7e64e60aca15 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go @@ -0,0 +1,97 @@ +package shares + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +// SetMetaData sets the MetaData on the specified Storage Share +func (client Client) SetMetaData(ctx context.Context, accountName, shareName string, metaData map[string]string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "SetMetaData", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "SetMetaData", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "SetMetaData", "`shareName` must be a lower-cased string.") + } + if err := metadata.Validate(metaData); err != nil { + return result, validation.NewError("shares.Client", "SetMetaData", fmt.Sprintf("`metadata` is not valid: %s.", err)) + } + + req, err := client.SetMetaDataPreparer(ctx, accountName, shareName, metaData) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "SetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.SetMetaDataSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "SetMetaData", resp, "Failure sending request") + return + } + + result, err = client.SetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "SetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// SetMetaDataPreparer prepares the SetMetaData request. +func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, shareName string, metaData map[string]string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + "comp": autorest.Encode("query", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + headers = metadata.SetIntoHeaders(headers, metaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetPropertiesSetMetaDataSender sends the SetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetMetaDataResponder handles the response to the SetMetaData request. The method always +// closes the http.Response Body. +func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go new file mode 100644 index 000000000000..31ef7c204703 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go @@ -0,0 +1,12 @@ +package shares + +type SignedIdentifier struct { + Id string `xml:"Id"` + AccessPolicy AccessPolicy `xml:"AccessPolicy"` +} + +type AccessPolicy struct { + Start string `xml:"Start"` + Expiry string `xml:"Expiry"` + Permission string `xml:"Permission"` +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go new file mode 100644 index 000000000000..95fa58de2c8c --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go @@ -0,0 +1,113 @@ +package shares + +import ( + "context" + "fmt" + "net/http" + "strconv" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetPropertiesResult struct { + autorest.Response + + MetaData map[string]string + ShareQuota int +} + +// GetProperties returns the properties about the specified Storage Share +func (client Client) GetProperties(ctx context.Context, accountName, shareName string) (result GetPropertiesResult, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "GetProperties", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "GetProperties", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "GetProperties", "`shareName` must be a lower-cased string.") + } + + req, err := client.GetPropertiesPreparer(ctx, accountName, shareName) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetPropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "GetProperties", resp, "Failure sending request") + return + } + + result, err = client.GetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetProperties", resp, "Failure responding to request") + return + } + + return +} + +// GetPropertiesPreparer prepares the GetProperties request. +func (client Client) GetPropertiesPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetPropertiesResponder handles the response to the GetProperties request. The method always +// closes the http.Response Body. +func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResult, err error) { + if resp.Header != nil { + result.MetaData = metadata.ParseFromHeaders(resp.Header) + + quotaRaw := resp.Header.Get("x-ms-share-quota") + if quotaRaw != "" { + quota, e := strconv.Atoi(quotaRaw) + if e != nil { + return result, fmt.Errorf("Error converting %q to an integer: %s", quotaRaw, err) + } + result.ShareQuota = quota + } + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go new file mode 100644 index 000000000000..b0f833674ec1 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go @@ -0,0 +1,95 @@ +package shares + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// SetProperties lets you update the Quota for the specified Storage Share +func (client Client) SetProperties(ctx context.Context, accountName, shareName string, newQuotaGB int) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "SetProperties", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "SetProperties", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "SetProperties", "`shareName` must be a lower-cased string.") + } + if newQuotaGB <= 0 || newQuotaGB > 102400 { + return result, validation.NewError("shares.Client", "SetProperties", "`newQuotaGB` must be greater than 0, and less than/equal to 100TB (102400 GB)") + } + + req, err := client.SetPropertiesPreparer(ctx, accountName, shareName, newQuotaGB) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "SetProperties", nil, "Failure preparing request") + return + } + + resp, err := client.SetPropertiesSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "SetProperties", resp, "Failure sending request") + return + } + + result, err = client.SetPropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "SetProperties", resp, "Failure responding to request") + return + } + + return +} + +// SetPropertiesPreparer prepares the SetProperties request. +func (client Client) SetPropertiesPreparer(ctx context.Context, accountName, shareName string, quotaGB int) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + "comp": autorest.Encode("query", "properties"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "x-ms-share-quota": quotaGB, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetPropertiesSender sends the SetProperties request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetPropertiesResponder handles the response to the SetProperties request. The method always +// closes the http.Response Body. +func (client Client) SetPropertiesResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go new file mode 100644 index 000000000000..c51d399ca062 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go @@ -0,0 +1,53 @@ +package shares + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given File Share +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, shareName string) string { + domain := endpoints.GetFileEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s", domain, shareName) +} + +// GetResourceManagerResourceID returns the Resource Manager specific +// ResourceID for a specific Storage Share +func (client Client) GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, shareName string) string { + fmtStr := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Storage/storageAccounts/%s/fileServices/default/shares/%s" + return fmt.Sprintf(fmtStr, subscriptionID, resourceGroup, accountName, shareName) +} + +type ResourceID struct { + AccountName string + ShareName string +} + +// ParseResourceID parses the specified Resource ID and returns an object +// which can be used to interact with the Storage Shares SDK +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.file.core.windows.net/Bar + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + shareName := strings.TrimPrefix(uri.Path, "/") + return &ResourceID{ + AccountName: *accountName, + ShareName: shareName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go new file mode 100644 index 000000000000..0ded38b1975a --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go @@ -0,0 +1,115 @@ +package shares + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type CreateSnapshotInput struct { + MetaData map[string]string +} + +type CreateSnapshotResult struct { + autorest.Response + + // This header is a DateTime value that uniquely identifies the share snapshot. + // The value of this header may be used in subsequent requests to access the share snapshot. + // This value is opaque. + SnapshotDateTime string +} + +// CreateSnapshot creates a read-only snapshot of the share +// A share can support creation of 200 share snapshots. Attempting to create more than 200 share snapshots fails with 409 (Conflict). +// Attempting to create a share snapshot while a previous Snapshot Share operation is in progress fails with 409 (Conflict). +func (client Client) CreateSnapshot(ctx context.Context, accountName, shareName string, input CreateSnapshotInput) (result CreateSnapshotResult, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "CreateSnapshot", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "CreateSnapshot", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "CreateSnapshot", "`shareName` must be a lower-cased string.") + } + if err := metadata.Validate(input.MetaData); err != nil { + return result, validation.NewError("shares.Client", "CreateSnapshot", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) + } + + req, err := client.CreateSnapshotPreparer(ctx, accountName, shareName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "CreateSnapshot", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSnapshotSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "CreateSnapshot", resp, "Failure sending request") + return + } + + result, err = client.CreateSnapshotResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "CreateSnapshot", resp, "Failure responding to request") + return + } + + return +} + +// CreateSnapshotPreparer prepares the CreateSnapshot request. +func (client Client) CreateSnapshotPreparer(ctx context.Context, accountName, shareName string, input CreateSnapshotInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "snapshot"), + "restype": autorest.Encode("query", "share"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = metadata.SetIntoHeaders(headers, input.MetaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CreateSnapshotSender sends the CreateSnapshot request. The method will close the +// http.Response Body if it receives an error. +func (client Client) CreateSnapshotSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateSnapshotResponder handles the response to the CreateSnapshot request. The method always +// closes the http.Response Body. +func (client Client) CreateSnapshotResponder(resp *http.Response) (result CreateSnapshotResult, err error) { + result.SnapshotDateTime = resp.Header.Get("x-ms-snapshot") + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go new file mode 100644 index 000000000000..1f5d665cb104 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go @@ -0,0 +1,94 @@ +package shares + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// DeleteSnapshot deletes the specified Snapshot of a Storage Share +func (client Client) DeleteSnapshot(ctx context.Context, accountName, shareName string, shareSnapshot string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "DeleteSnapshot", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "DeleteSnapshot", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "DeleteSnapshot", "`shareName` must be a lower-cased string.") + } + if shareSnapshot == "" { + return result, validation.NewError("shares.Client", "DeleteSnapshot", "`shareSnapshot` cannot be an empty string.") + } + + req, err := client.DeleteSnapshotPreparer(ctx, accountName, shareName, shareSnapshot) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "DeleteSnapshot", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSnapshotSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "DeleteSnapshot", resp, "Failure sending request") + return + } + + result, err = client.DeleteSnapshotResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "DeleteSnapshot", resp, "Failure responding to request") + return + } + + return +} + +// DeleteSnapshotPreparer prepares the DeleteSnapshot request. +func (client Client) DeleteSnapshotPreparer(ctx context.Context, accountName, shareName string, shareSnapshot string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("path", "share"), + "sharesnapshot": autorest.Encode("query", shareSnapshot), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSnapshotSender sends the DeleteSnapshot request. The method will close the +// http.Response Body if it receives an error. +func (client Client) DeleteSnapshotSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteSnapshotResponder handles the response to the DeleteSnapshot request. The method always +// closes the http.Response Body. +func (client Client) DeleteSnapshotResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go new file mode 100644 index 000000000000..2cf5f16f618e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go @@ -0,0 +1,105 @@ +package shares + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetSnapshotPropertiesResult struct { + autorest.Response + + MetaData map[string]string +} + +// GetSnapshot gets information about the specified Snapshot of the specified Storage Share +func (client Client) GetSnapshot(ctx context.Context, accountName, shareName, snapshotShare string) (result GetSnapshotPropertiesResult, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "GetSnapshot", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "GetSnapshot", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "GetSnapshot", "`shareName` must be a lower-cased string.") + } + if snapshotShare == "" { + return result, validation.NewError("shares.Client", "GetSnapshot", "`snapshotShare` cannot be an empty string.") + } + + req, err := client.GetSnapshotPreparer(ctx, accountName, shareName, snapshotShare) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetSnapshot", nil, "Failure preparing request") + return + } + + resp, err := client.GetSnapshotSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "GetSnapshot", resp, "Failure sending request") + return + } + + result, err = client.GetSnapshotResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetSnapshot", resp, "Failure responding to request") + return + } + + return +} + +// GetSnapshotPreparer prepares the GetSnapshot request. +func (client Client) GetSnapshotPreparer(ctx context.Context, accountName, shareName, snapshotShare string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + "snapshot": autorest.Encode("query", snapshotShare), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetSnapshotSender sends the GetSnapshot request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetSnapshotSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetSnapshotResponder handles the response to the GetSnapshot request. The method always +// closes the http.Response Body. +func (client Client) GetSnapshotResponder(resp *http.Response) (result GetSnapshotPropertiesResult, err error) { + if resp.Header != nil { + result.MetaData = metadata.ParseFromHeaders(resp.Header) + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go new file mode 100644 index 000000000000..3539eccbcd0e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go @@ -0,0 +1,100 @@ +package shares + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetStatsResult struct { + autorest.Response + + // The approximate size of the data stored on the share. + // Note that this value may not include all recently created or recently resized files. + ShareUsageBytes int64 `xml:"ShareUsageBytes"` +} + +// GetStats returns information about the specified Storage Share +func (client Client) GetStats(ctx context.Context, accountName, shareName string) (result GetStatsResult, err error) { + if accountName == "" { + return result, validation.NewError("shares.Client", "GetStats", "`accountName` cannot be an empty string.") + } + if shareName == "" { + return result, validation.NewError("shares.Client", "GetStats", "`shareName` cannot be an empty string.") + } + if strings.ToLower(shareName) != shareName { + return result, validation.NewError("shares.Client", "GetStats", "`shareName` must be a lower-cased string.") + } + + req, err := client.GetStatsPreparer(ctx, accountName, shareName) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetStats", nil, "Failure preparing request") + return + } + + resp, err := client.GetStatsSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "shares.Client", "GetStats", resp, "Failure sending request") + return + } + + result, err = client.GetStatsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "shares.Client", "GetStats", resp, "Failure responding to request") + return + } + + return +} + +// GetStatsPreparer prepares the GetStats request. +func (client Client) GetStatsPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "shareName": autorest.Encode("path", shareName), + } + + queryParameters := map[string]interface{}{ + "restype": autorest.Encode("query", "share"), + "comp": autorest.Encode("query", "stats"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{shareName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) GetStatsSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetStatsResponder handles the response to the GetStats request. The method always +// closes the http.Response Body. +func (client Client) GetStatsResponder(resp *http.Response) (result GetStatsResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go new file mode 100644 index 000000000000..653693959b6f --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go @@ -0,0 +1,14 @@ +package shares + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md new file mode 100644 index 000000000000..b8b84a3799a8 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md @@ -0,0 +1,43 @@ +## Queue Storage Queues SDK for API version 2020-08-04 + +This package allows you to interact with the Queues Queue Storage API + +### Supported Authorizers + +* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) +* SharedKeyLite (Blob, File & Queue) + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + queueName := "myqueue" + + storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) + queuesClient := queues.New() + queuesClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + metadata := map[string]string{ + "hello": "world", + } + if _, err := queuesClient.Create(ctx, accountName, queueName, metadata); err != nil { + return fmt.Errorf("Error creating Queue: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go new file mode 100644 index 000000000000..e4c14220b68c --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go @@ -0,0 +1,17 @@ +package queues + +import ( + "context" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageQueue interface { + Delete(ctx context.Context, accountName, queueName string) (result autorest.Response, err error) + GetMetaData(ctx context.Context, accountName, queueName string) (result GetMetaDataResult, err error) + SetMetaData(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) + Create(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) + GetResourceID(accountName, queueName string) string + SetServiceProperties(ctx context.Context, accountName string, properties StorageServiceProperties) (result autorest.Response, err error) + GetServiceProperties(ctx context.Context, accountName string) (result StorageServicePropertiesResponse, err error) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go new file mode 100644 index 000000000000..2f8008582b93 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go @@ -0,0 +1,25 @@ +package queues + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Queue Storage Shares. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go new file mode 100644 index 000000000000..f18910a88d9e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go @@ -0,0 +1,92 @@ +package queues + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +// Create creates the specified Queue within the specified Storage Account +func (client Client) Create(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("queues.Client", "Create", "`accountName` cannot be an empty string.") + } + if queueName == "" { + return result, validation.NewError("queues.Client", "Create", "`queueName` cannot be an empty string.") + } + if strings.ToLower(queueName) != queueName { + return result, validation.NewError("queues.Client", "Create", "`queueName` must be a lower-cased string.") + } + if err := metadata.Validate(metaData); err != nil { + return result, validation.NewError("queues.Client", "Create", fmt.Sprintf("`metadata` is not valid: %s.", err)) + } + + req, err := client.CreatePreparer(ctx, accountName, queueName, metaData) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "queues.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "Create", resp, "Failure responding to request") + return + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName string, queueName string, metaData map[string]string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "queueName": autorest.Encode("path", queueName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = metadata.SetIntoHeaders(headers, metaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{queueName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusCreated), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go new file mode 100644 index 000000000000..5f705959c446 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go @@ -0,0 +1,85 @@ +package queues + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete deletes the specified Queue within the specified Storage Account +func (client Client) Delete(ctx context.Context, accountName, queueName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("queues.Client", "Delete", "`accountName` cannot be an empty string.") + } + if queueName == "" { + return result, validation.NewError("queues.Client", "Delete", "`queueName` cannot be an empty string.") + } + if strings.ToLower(queueName) != queueName { + return result, validation.NewError("queues.Client", "Delete", "`queueName` must be a lower-cased string.") + } + + req, err := client.DeletePreparer(ctx, accountName, queueName) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "queues.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName string, queueName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "queueName": autorest.Encode("path", queueName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{queueName}", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go new file mode 100644 index 000000000000..9c230b613ad3 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go @@ -0,0 +1,101 @@ +package queues + +import ( + "context" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +type GetMetaDataResult struct { + autorest.Response + + MetaData map[string]string +} + +// GetMetaData returns the metadata for this Queue +func (client Client) GetMetaData(ctx context.Context, accountName, queueName string) (result GetMetaDataResult, err error) { + if accountName == "" { + return result, validation.NewError("queues.Client", "GetMetaData", "`accountName` cannot be an empty string.") + } + if queueName == "" { + return result, validation.NewError("queues.Client", "GetMetaData", "`queueName` cannot be an empty string.") + } + if strings.ToLower(queueName) != queueName { + return result, validation.NewError("queues.Client", "GetMetaData", "`queueName` must be a lower-cased string.") + } + + req, err := client.GetMetaDataPreparer(ctx, accountName, queueName) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "GetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.GetMetaDataSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "queues.Client", "GetMetaData", resp, "Failure sending request") + return + } + + result, err = client.GetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "GetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// GetMetaDataPreparer prepares the GetMetaData request. +func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, queueName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "queueName": autorest.Encode("path", queueName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{queueName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetMetaDataSender sends the GetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetMetaDataResponder handles the response to the GetMetaData request. The method always +// closes the http.Response Body. +func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { + if resp != nil { + result.MetaData = metadata.ParseFromHeaders(resp.Header) + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go new file mode 100644 index 000000000000..51154a5c4334 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go @@ -0,0 +1,97 @@ +package queues + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" + "github.com/tombuildsstuff/giovanni/storage/internal/metadata" +) + +// SetMetaData returns the metadata for this Queue +func (client Client) SetMetaData(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("queues.Client", "SetMetaData", "`accountName` cannot be an empty string.") + } + if queueName == "" { + return result, validation.NewError("queues.Client", "SetMetaData", "`queueName` cannot be an empty string.") + } + if strings.ToLower(queueName) != queueName { + return result, validation.NewError("queues.Client", "SetMetaData", "`queueName` must be a lower-cased string.") + } + if err := metadata.Validate(metaData); err != nil { + return result, validation.NewError("queues.Client", "SetMetaData", fmt.Sprintf("`metadata` is not valid: %s.", err)) + } + + req, err := client.SetMetaDataPreparer(ctx, accountName, queueName, metaData) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "SetMetaData", nil, "Failure preparing request") + return + } + + resp, err := client.SetMetaDataSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "queues.Client", "SetMetaData", resp, "Failure sending request") + return + } + + result, err = client.SetMetaDataResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "SetMetaData", resp, "Failure responding to request") + return + } + + return +} + +// SetMetaDataPreparer prepares the SetMetaData request. +func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, queueName string, metaData map[string]string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "queueName": autorest.Encode("path", queueName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "metadata"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + headers = metadata.SetIntoHeaders(headers, metaData) + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{queueName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetMetaDataSender sends the SetMetaData request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetMetaDataResponder handles the response to the SetMetaData request. The method always +// closes the http.Response Body. +func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go new file mode 100644 index 000000000000..0afe8b6060cb --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go @@ -0,0 +1,42 @@ +package queues + +type StorageServiceProperties struct { + Logging *LoggingConfig `xml:"Logging,omitempty"` + HourMetrics *MetricsConfig `xml:"HourMetrics,omitempty"` + MinuteMetrics *MetricsConfig `xml:"MinuteMetrics,omitempty"` + Cors *Cors `xml:"Cors,omitempty"` +} + +type LoggingConfig struct { + Version string `xml:"Version"` + Delete bool `xml:"Delete"` + Read bool `xml:"Read"` + Write bool `xml:"Write"` + RetentionPolicy RetentionPolicy `xml:"RetentionPolicy"` +} + +type MetricsConfig struct { + Version string `xml:"Version"` + Enabled bool `xml:"Enabled"` + RetentionPolicy RetentionPolicy `xml:"RetentionPolicy"` + + // Element IncludeAPIs is only expected when Metrics is enabled + IncludeAPIs *bool `xml:"IncludeAPIs,omitempty"` +} + +type RetentionPolicy struct { + Enabled bool `xml:"Enabled"` + Days int `xml:"Days"` +} + +type Cors struct { + CorsRule []CorsRule `xml:"CorsRule"` +} + +type CorsRule struct { + AllowedOrigins string `xml:"AllowedOrigins"` + AllowedMethods string `xml:"AllowedMethods"` + AllowedHeaders string `xml:"AllowedHeaders` + ExposedHeaders string `xml:"ExposedHeaders"` + MaxAgeInSeconds int `xml:"MaxAgeInSeconds"` +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go new file mode 100644 index 000000000000..a0e51ad34354 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go @@ -0,0 +1,86 @@ +package queues + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type StorageServicePropertiesResponse struct { + StorageServiceProperties + autorest.Response +} + +// SetServiceProperties gets the properties for this queue +func (client Client) GetServiceProperties(ctx context.Context, accountName string) (result StorageServicePropertiesResponse, err error) { + if accountName == "" { + return result, validation.NewError("queues.Client", "GetServiceProperties", "`accountName` cannot be an empty string.") + } + + req, err := client.GetServicePropertiesPreparer(ctx, accountName) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "GetServiceProperties", nil, "Failure preparing request") + return + } + + resp, err := client.GetServicePropertiesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "queues.Client", "GetServiceProperties", resp, "Failure sending request") + return + } + + result, err = client.GetServicePropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "GetServiceProperties", resp, "Failure responding to request") + return + } + + return +} + +// GetServicePropertiesPreparer prepares the GetServiceProperties request. +func (client Client) GetServicePropertiesPreparer(ctx context.Context, accountName string) (*http.Request, error) { + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "properties"), + "restype": autorest.Encode("path", "service"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), + autorest.WithPath("/"), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetServicePropertiesSender sends the GetServiceProperties request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetServicePropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetServicePropertiesResponder handles the response to the GetServiceProperties request. The method always +// closes the http.Response Body. +func (client Client) GetServicePropertiesResponder(resp *http.Response) (result StorageServicePropertiesResponse, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go new file mode 100644 index 000000000000..33dd40b3da1f --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go @@ -0,0 +1,81 @@ +package queues + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// SetServiceProperties sets the properties for this queue +func (client Client) SetServiceProperties(ctx context.Context, accountName string, properties StorageServiceProperties) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("queues.Client", "SetServiceProperties", "`accountName` cannot be an empty string.") + } + + req, err := client.SetServicePropertiesPreparer(ctx, accountName, properties) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "SetServiceProperties", nil, "Failure preparing request") + return + } + + resp, err := client.SetServicePropertiesSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "queues.Client", "SetServiceProperties", resp, "Failure sending request") + return + } + + result, err = client.SetServicePropertiesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "queues.Client", "SetServiceProperties", resp, "Failure responding to request") + return + } + + return +} + +// SetServicePropertiesPreparer prepares the SetServiceProperties request. +func (client Client) SetServicePropertiesPreparer(ctx context.Context, accountName string, properties StorageServiceProperties) (*http.Request, error) { + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("path", "properties"), + "restype": autorest.Encode("path", "service"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), + autorest.WithPath("/"), + autorest.WithQueryParameters(queryParameters), + autorest.WithXML(properties), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetServicePropertiesSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always +// closes the http.Response Body. +func (client Client) SetServicePropertiesResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusAccepted), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go new file mode 100644 index 000000000000..912923abca0d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go @@ -0,0 +1,46 @@ +package queues + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Queue +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, queueName string) string { + domain := endpoints.GetQueueEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s", domain, queueName) +} + +type ResourceID struct { + AccountName string + QueueName string +} + +// ParseResourceID parses the Resource ID and returns an Object which +// can be used to interact with a Queue within a Storage Account +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.queue.core.windows.net/Bar + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + queueName := strings.TrimPrefix(uri.Path, "/") + return &ResourceID{ + AccountName: *accountName, + QueueName: queueName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go new file mode 100644 index 000000000000..9d3e68949fec --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go @@ -0,0 +1,14 @@ +package queues + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md new file mode 100644 index 000000000000..e59b5a28335a --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md @@ -0,0 +1,48 @@ +## Table Storage Entities SDK for API version 2020-08-04 + +This package allows you to interact with the Entities Table Storage API + +### Supported Authorizers + +* SharedKeyLite (Table) + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + tableName := "mytable" + + storageAuth := autorest.NewSharedKeyLiteTableAuthorizer(accountName, storageAccountKey) + entitiesClient := entities.New() + entitiesClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + input := entities.InsertEntityInput{ + PartitionKey: "abc", + RowKey: "123", + MetaDataLevel: entities.NoMetaData, + Entity: map[string]interface{}{ + "title": "Don't Kill My Vibe", + "artist": "Sigrid", + }, + } + if _, err := entitiesClient.Insert(ctx, accountName, tableName, input); err != nil { + return fmt.Errorf("Error creating Entity: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go new file mode 100644 index 000000000000..d4d20a723457 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go @@ -0,0 +1,17 @@ +package entities + +import ( + "context" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageTableEntity interface { + Delete(ctx context.Context, accountName, tableName string, input DeleteEntityInput) (result autorest.Response, err error) + Insert(ctx context.Context, accountName, tableName string, input InsertEntityInput) (result autorest.Response, err error) + InsertOrReplace(ctx context.Context, accountName, tableName string, input InsertOrReplaceEntityInput) (result autorest.Response, err error) + InsertOrMerge(ctx context.Context, accountName, tableName string, input InsertOrMergeEntityInput) (result autorest.Response, err error) + Query(ctx context.Context, accountName, tableName string, input QueryEntitiesInput) (result QueryEntitiesResult, err error) + Get(ctx context.Context, accountName, tableName string, input GetEntityInput) (result GetEntityResult, err error) + GetResourceID(accountName, tableName, partitionKey, rowKey string) string +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go new file mode 100644 index 000000000000..17e9d759fb9e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go @@ -0,0 +1,25 @@ +package entities + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Table Storage Shares. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go new file mode 100644 index 000000000000..83e9188e5e9e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go @@ -0,0 +1,99 @@ +package entities + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type DeleteEntityInput struct { + // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. + // Together, these properties form the primary key and must be unique within the table. + // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. + // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, + // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. + RowKey string + PartitionKey string +} + +// Delete deletes an existing entity in a table. +func (client Client) Delete(ctx context.Context, accountName, tableName string, input DeleteEntityInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("entities.Client", "Delete", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("entities.Client", "Delete", "`tableName` cannot be an empty string.") + } + if input.PartitionKey == "" { + return result, validation.NewError("entities.Client", "Delete", "`input.PartitionKey` cannot be an empty string.") + } + if input.RowKey == "" { + return result, validation.NewError("entities.Client", "Delete", "`input.RowKey` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, tableName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "entities.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName, tableName string, input DeleteEntityInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + "partitionKey": autorest.Encode("path", input.PartitionKey), + "rowKey": autorest.Encode("path", input.RowKey), + } + + headers := map[string]interface{}{ + // TODO: support for eTags + "If-Match": "*", + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}', RowKey='{rowKey}')", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go new file mode 100644 index 000000000000..bdb40180b54d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go @@ -0,0 +1,108 @@ +package entities + +import ( + "context" + "fmt" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetEntityInput struct { + PartitionKey string + RowKey string + + // The Level of MetaData which should be returned + MetaDataLevel MetaDataLevel +} + +type GetEntityResult struct { + autorest.Response + + Entity map[string]interface{} +} + +// Get queries entities in a table and includes the $filter and $select options. +func (client Client) Get(ctx context.Context, accountName, tableName string, input GetEntityInput) (result GetEntityResult, err error) { + if accountName == "" { + return result, validation.NewError("entities.Client", "Get", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("entities.Client", "Get", "`tableName` cannot be an empty string.") + } + if input.PartitionKey == "" { + return result, validation.NewError("entities.Client", "Get", "`input.PartitionKey` cannot be an empty string.") + } + if input.RowKey == "" { + return result, validation.NewError("entities.Client", "Get", "`input.RowKey` cannot be an empty string.") + } + + req, err := client.GetPreparer(ctx, accountName, tableName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "entities.Client", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Get", resp, "Failure responding to request") + return + } + + return +} + +// GetPreparer prepares the Get request. +func (client Client) GetPreparer(ctx context.Context, accountName, tableName string, input GetEntityInput) (*http.Request, error) { + + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + "partitionKey": autorest.Encode("path", input.PartitionKey), + "rowKey": autorest.Encode("path", input.RowKey), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "Accept": fmt.Sprintf("application/json;odata=%s", input.MetaDataLevel), + "DataServiceVersion": "3.0;NetFx", + "MaxDataServiceVersion": "3.0;NetFx", + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}',RowKey='{rowKey}')", pathParameters), + autorest.WithHeaders(headers)) + 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 Client) GetSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client Client) GetResponder(resp *http.Response) (result GetEntityResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result.Entity), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go new file mode 100644 index 000000000000..92b05cef5499 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go @@ -0,0 +1,112 @@ +package entities + +import ( + "context" + "fmt" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type InsertEntityInput struct { + // The level of MetaData provided for this Entity + MetaDataLevel MetaDataLevel + + // The Entity which should be inserted, by default all values are strings + // To explicitly type a property, specify the appropriate OData data type by setting + // the m:type attribute within the property definition + Entity map[string]interface{} + + // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. + // Together, these properties form the primary key and must be unique within the table. + // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. + // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, + // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. + RowKey string + PartitionKey string +} + +// Insert inserts a new entity into a table. +func (client Client) Insert(ctx context.Context, accountName, tableName string, input InsertEntityInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("entities.Client", "Insert", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("entities.Client", "Insert", "`tableName` cannot be an empty string.") + } + if input.PartitionKey == "" { + return result, validation.NewError("entities.Client", "Insert", "`input.PartitionKey` cannot be an empty string.") + } + if input.RowKey == "" { + return result, validation.NewError("entities.Client", "Insert", "`input.RowKey` cannot be an empty string.") + } + + req, err := client.InsertPreparer(ctx, accountName, tableName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Insert", nil, "Failure preparing request") + return + } + + resp, err := client.InsertSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "entities.Client", "Insert", resp, "Failure sending request") + return + } + + result, err = client.InsertResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Insert", resp, "Failure responding to request") + return + } + + return +} + +// InsertPreparer prepares the Insert request. +func (client Client) InsertPreparer(ctx context.Context, accountName, tableName string, input InsertEntityInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "Accept": fmt.Sprintf("application/json;odata=%s", input.MetaDataLevel), + "Prefer": "return-no-content", + } + + input.Entity["PartitionKey"] = input.PartitionKey + input.Entity["RowKey"] = input.RowKey + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json"), + autorest.AsPost(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}", pathParameters), + autorest.WithJSON(input.Entity), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// InsertSender sends the Insert request. The method will close the +// http.Response Body if it receives an error. +func (client Client) InsertSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// InsertResponder handles the response to the Insert request. The method always +// closes the http.Response Body. +func (client Client) InsertResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go new file mode 100644 index 000000000000..1fb4ed3df164 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go @@ -0,0 +1,108 @@ +package entities + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type InsertOrMergeEntityInput struct { + // The Entity which should be inserted, by default all values are strings + // To explicitly type a property, specify the appropriate OData data type by setting + // the m:type attribute within the property definition + Entity map[string]interface{} + + // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. + // Together, these properties form the primary key and must be unique within the table. + // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. + // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, + // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. + RowKey string + PartitionKey string +} + +// InsertOrMerge updates an existing entity or inserts a new entity if it does not exist in the table. +// Because this operation can insert or update an entity, it is also known as an upsert operation. +func (client Client) InsertOrMerge(ctx context.Context, accountName, tableName string, input InsertOrMergeEntityInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("entities.Client", "InsertOrMerge", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("entities.Client", "InsertOrMerge", "`tableName` cannot be an empty string.") + } + if input.PartitionKey == "" { + return result, validation.NewError("entities.Client", "InsertOrMerge", "`input.PartitionKey` cannot be an empty string.") + } + if input.RowKey == "" { + return result, validation.NewError("entities.Client", "InsertOrMerge", "`input.RowKey` cannot be an empty string.") + } + + req, err := client.InsertOrMergePreparer(ctx, accountName, tableName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrMerge", nil, "Failure preparing request") + return + } + + resp, err := client.InsertOrMergeSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrMerge", resp, "Failure sending request") + return + } + + result, err = client.InsertOrMergeResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrMerge", resp, "Failure responding to request") + return + } + + return +} + +// InsertOrMergePreparer prepares the InsertOrMerge request. +func (client Client) InsertOrMergePreparer(ctx context.Context, accountName, tableName string, input InsertOrMergeEntityInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + "partitionKey": autorest.Encode("path", input.PartitionKey), + "rowKey": autorest.Encode("path", input.RowKey), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "Accept": "application/json", + "Prefer": "return-no-content", + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json"), + autorest.AsMerge(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}', RowKey='{rowKey}')", pathParameters), + autorest.WithJSON(input.Entity), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// InsertOrMergeSender sends the InsertOrMerge request. The method will close the +// http.Response Body if it receives an error. +func (client Client) InsertOrMergeSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// InsertOrMergeResponder handles the response to the InsertOrMerge request. The method always +// closes the http.Response Body. +func (client Client) InsertOrMergeResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go new file mode 100644 index 000000000000..036ba5de5fe7 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go @@ -0,0 +1,108 @@ +package entities + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type InsertOrReplaceEntityInput struct { + // The Entity which should be inserted, by default all values are strings + // To explicitly type a property, specify the appropriate OData data type by setting + // the m:type attribute within the property definition + Entity map[string]interface{} + + // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. + // Together, these properties form the primary key and must be unique within the table. + // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. + // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, + // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. + RowKey string + PartitionKey string +} + +// InsertOrReplace replaces an existing entity or inserts a new entity if it does not exist in the table. +// Because this operation can insert or update an entity, it is also known as an upsert operation. +func (client Client) InsertOrReplace(ctx context.Context, accountName, tableName string, input InsertOrReplaceEntityInput) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("entities.Client", "InsertOrReplace", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("entities.Client", "InsertOrReplace", "`tableName` cannot be an empty string.") + } + if input.PartitionKey == "" { + return result, validation.NewError("entities.Client", "InsertOrReplace", "`input.PartitionKey` cannot be an empty string.") + } + if input.RowKey == "" { + return result, validation.NewError("entities.Client", "InsertOrReplace", "`input.RowKey` cannot be an empty string.") + } + + req, err := client.InsertOrReplacePreparer(ctx, accountName, tableName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrReplace", nil, "Failure preparing request") + return + } + + resp, err := client.InsertOrReplaceSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrReplace", resp, "Failure sending request") + return + } + + result, err = client.InsertOrReplaceResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrReplace", resp, "Failure responding to request") + return + } + + return +} + +// InsertOrReplacePreparer prepares the InsertOrReplace request. +func (client Client) InsertOrReplacePreparer(ctx context.Context, accountName, tableName string, input InsertOrReplaceEntityInput) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + "partitionKey": autorest.Encode("path", input.PartitionKey), + "rowKey": autorest.Encode("path", input.RowKey), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "Accept": "application/json", + "Prefer": "return-no-content", + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json"), + autorest.AsMerge(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}', RowKey='{rowKey}')", pathParameters), + autorest.WithJSON(input.Entity), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// InsertOrReplaceSender sends the InsertOrReplace request. The method will close the +// http.Response Body if it receives an error. +func (client Client) InsertOrReplaceSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// InsertOrReplaceResponder handles the response to the InsertOrReplace request. The method always +// closes the http.Response Body. +func (client Client) InsertOrReplaceResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go new file mode 100644 index 000000000000..e3c6cccb59ce --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go @@ -0,0 +1,9 @@ +package entities + +type MetaDataLevel string + +var ( + NoMetaData MetaDataLevel = "nometadata" + MinimalMetaData MetaDataLevel = "minimalmetadata" + FullMetaData MetaDataLevel = "fullmetadata" +) diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go new file mode 100644 index 000000000000..c1ba3706be7d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go @@ -0,0 +1,162 @@ +package entities + +import ( + "context" + "fmt" + "net/http" + "strings" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type QueryEntitiesInput struct { + // An optional OData filter + Filter *string + + // An optional comma-separated + PropertyNamesToSelect *[]string + + // An optional OData top + Top *int + + PartitionKey string + RowKey string + + // The Level of MetaData which should be returned + MetaDataLevel MetaDataLevel + + // The Next Partition Key used to load data from a previous point + NextPartitionKey *string + + // The Next Row Key used to load data from a previous point + NextRowKey *string +} + +type QueryEntitiesResult struct { + autorest.Response + + NextPartitionKey string + NextRowKey string + + MetaData string `json:"odata.metadata,omitempty"` + Entities []map[string]interface{} `json:"value"` +} + +// Query queries entities in a table and includes the $filter and $select options. +func (client Client) Query(ctx context.Context, accountName, tableName string, input QueryEntitiesInput) (result QueryEntitiesResult, err error) { + if accountName == "" { + return result, validation.NewError("entities.Client", "Query", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("entities.Client", "Query", "`tableName` cannot be an empty string.") + } + + req, err := client.QueryPreparer(ctx, accountName, tableName, input) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Query", nil, "Failure preparing request") + return + } + + resp, err := client.QuerySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "entities.Client", "Query", resp, "Failure sending request") + return + } + + result, err = client.QueryResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "entities.Client", "Query", resp, "Failure responding to request") + return + } + + return +} + +// QueryPreparer prepares the Query request. +func (client Client) QueryPreparer(ctx context.Context, accountName, tableName string, input QueryEntitiesInput) (*http.Request, error) { + + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + "additionalParameters": "", + } + + //PartitionKey='',RowKey='' + additionalParams := make([]string, 0) + if input.PartitionKey != "" { + additionalParams = append(additionalParams, fmt.Sprintf("PartitionKey='%s'", input.PartitionKey)) + } + if input.RowKey != "" { + additionalParams = append(additionalParams, fmt.Sprintf("RowKey='%s'", input.RowKey)) + } + if len(additionalParams) > 0 { + pathParameters["additionalParameters"] = autorest.Encode("path", strings.Join(additionalParams, ",")) + } + + queryParameters := map[string]interface{}{} + + if input.Filter != nil { + queryParameters["$filter"] = autorest.Encode("query", *input.Filter) + } + + if input.PropertyNamesToSelect != nil { + queryParameters["$select"] = autorest.Encode("query", strings.Join(*input.PropertyNamesToSelect, ",")) + } + + if input.Top != nil { + queryParameters["$top"] = autorest.Encode("query", *input.Top) + } + + if input.NextPartitionKey != nil { + queryParameters["NextPartitionKey"] = *input.NextPartitionKey + } + + if input.NextRowKey != nil { + queryParameters["NextRowKey"] = *input.NextRowKey + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "Accept": fmt.Sprintf("application/json;odata=%s", input.MetaDataLevel), + "DataServiceVersion": "3.0;NetFx", + "MaxDataServiceVersion": "3.0;NetFx", + } + + // GET /myaccount/Customers()?$filter=(Rating%20ge%203)%20and%20(Rating%20le%206)&$select=PartitionKey,RowKey,Address,CustomerSince + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}({additionalParameters})", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + 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 Client) QuerySender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// QueryResponder handles the response to the Query request. The method always +// closes the http.Response Body. +func (client Client) QueryResponder(resp *http.Response) (result QueryEntitiesResult, err error) { + if resp != nil && resp.Header != nil { + result.NextPartitionKey = resp.Header.Get("x-ms-continuation-NextPartitionKey") + result.NextRowKey = resp.Header.Get("x-ms-continuation-NextRowKey") + } + + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go new file mode 100644 index 000000000000..249671dc91bf --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go @@ -0,0 +1,91 @@ +package entities + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Entity +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, tableName, partitionKey, rowKey string) string { + domain := endpoints.GetTableEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/%s(PartitionKey='%s',RowKey='%s')", domain, tableName, partitionKey, rowKey) +} + +type ResourceID struct { + AccountName string + TableName string + PartitionKey string + RowKey string +} + +// ParseResourceID parses the specified Resource ID and returns an object which +// can be used to look up the specified Entity within the specified Table +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://account1.table.core.chinacloudapi.cn/table1(PartitionKey='partition1',RowKey='row1') + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + // assume there a `Table('')` + path := strings.TrimPrefix(uri.Path, "/") + if !strings.Contains(uri.Path, "(") || !strings.HasSuffix(uri.Path, ")") { + return nil, fmt.Errorf("Expected the Table Name to be in the format `tables(PartitionKey='',RowKey='')` but got %q", path) + } + + // NOTE: honestly this could probably be a RegEx, but this seemed like the simplest way to + // allow these two fields to be specified in either order + indexOfBracket := strings.IndexByte(path, '(') + tableName := path[0:indexOfBracket] + + // trim off the brackets + temp := strings.TrimPrefix(path, fmt.Sprintf("%s(", tableName)) + temp = strings.TrimSuffix(temp, ")") + + dictionary := strings.Split(temp, ",") + partitionKey := "" + rowKey := "" + for _, v := range dictionary { + split := strings.Split(v, "=") + if len(split) != 2 { + return nil, fmt.Errorf("Expected 2 segments but got %d for %q", len(split), v) + } + + key := split[0] + value := strings.TrimSuffix(strings.TrimPrefix(split[1], "'"), "'") + if strings.EqualFold(key, "PartitionKey") { + partitionKey = value + } else if strings.EqualFold(key, "RowKey") { + rowKey = value + } else { + return nil, fmt.Errorf("Unexpected Key %q", key) + } + } + + if partitionKey == "" { + return nil, fmt.Errorf("Expected a PartitionKey but didn't get one") + } + if rowKey == "" { + return nil, fmt.Errorf("Expected a RowKey but didn't get one") + } + + return &ResourceID{ + AccountName: *accountName, + TableName: tableName, + PartitionKey: partitionKey, + RowKey: rowKey, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go new file mode 100644 index 000000000000..6270953c7923 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go @@ -0,0 +1,14 @@ +package entities + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md new file mode 100644 index 000000000000..40ec34959a79 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md @@ -0,0 +1,39 @@ +## Table Storage Tables SDK for API version 2020-08-04 + +This package allows you to interact with the Tables Table Storage API + +### Supported Authorizers + +* SharedKeyLite (Table) + +### Example Usage + +```go +package main + +import ( + "context" + "fmt" + "time" + + "github.com/Azure/go-autorest/autorest" + "github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables" +) + +func Example() error { + accountName := "storageaccount1" + storageAccountKey := "ABC123...." + tableName := "mytable" + + storageAuth := autorest.NewSharedKeyLiteTableAuthorizer(accountName, storageAccountKey) + tablesClient := tables.New() + tablesClient.Client.Authorizer = storageAuth + + ctx := context.TODO() + if _, err := tablesClient.Insert(ctx, accountName, tableName); err != nil { + return fmt.Errorf("Error creating Table: %s", err) + } + + return nil +} +``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go new file mode 100644 index 000000000000..0ef00006530f --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go @@ -0,0 +1,93 @@ +package tables + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetACLResult struct { + autorest.Response + + SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` +} + +// GetACL returns the Access Control List for the specified Table +func (client Client) GetACL(ctx context.Context, accountName, tableName string) (result GetACLResult, err error) { + if accountName == "" { + return result, validation.NewError("tables.Client", "GetACL", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("tables.Client", "GetACL", "`tableName` cannot be an empty string.") + } + + req, err := client.GetACLPreparer(ctx, accountName, tableName) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "GetACL", nil, "Failure preparing request") + return + } + + resp, err := client.GetACLSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "tables.Client", "GetACL", resp, "Failure sending request") + return + } + + result, err = client.GetACLResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "GetACL", resp, "Failure responding to request") + return + } + + return +} + +// GetACLPreparer prepares the GetACL request. +func (client Client) GetACLPreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "acl"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetACLSender sends the GetACL request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetACLSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// GetACLResponder handles the response to the GetACL request. The method always +// closes the http.Response Body. +func (client Client) GetACLResponder(resp *http.Response) (result GetACLResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingXML(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go new file mode 100644 index 000000000000..c26bffc834d1 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go @@ -0,0 +1,98 @@ +package tables + +import ( + "context" + "encoding/xml" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type setAcl struct { + SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` + + XMLName xml.Name `xml:"SignedIdentifiers"` +} + +// SetACL sets the specified Access Control List for the specified Table +func (client Client) SetACL(ctx context.Context, accountName, tableName string, acls []SignedIdentifier) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("tables.Client", "SetACL", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("tables.Client", "SetACL", "`tableName` cannot be an empty string.") + } + + req, err := client.SetACLPreparer(ctx, accountName, tableName, acls) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "SetACL", nil, "Failure preparing request") + return + } + + resp, err := client.SetACLSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "tables.Client", "SetACL", resp, "Failure sending request") + return + } + + result, err = client.SetACLResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "SetACL", resp, "Failure responding to request") + return + } + + return +} + +// SetACLPreparer prepares the SetACL request. +func (client Client) SetACLPreparer(ctx context.Context, accountName, tableName string, acls []SignedIdentifier) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + } + + queryParameters := map[string]interface{}{ + "comp": autorest.Encode("query", "acl"), + } + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + } + + input := setAcl{ + SignedIdentifiers: acls, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/xml; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/{tableName}", pathParameters), + autorest.WithQueryParameters(queryParameters), + autorest.WithHeaders(headers), + autorest.WithXML(&input)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// SetACLSender sends the SetACL request. The method will close the +// http.Response Body if it receives an error. +func (client Client) SetACLSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// SetACLResponder handles the response to the SetACL request. The method always +// closes the http.Response Body. +func (client Client) SetACLResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go new file mode 100644 index 000000000000..d869819ff21e --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go @@ -0,0 +1,17 @@ +package tables + +import ( + "context" + + "github.com/Azure/go-autorest/autorest" +) + +type StorageTable interface { + Delete(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) + Exists(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) + GetACL(ctx context.Context, accountName, tableName string) (result GetACLResult, err error) + Create(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) + GetResourceID(accountName, tableName string) string + Query(ctx context.Context, accountName string, metaDataLevel MetaDataLevel) (result GetResult, err error) + SetACL(ctx context.Context, accountName, tableName string, acls []SignedIdentifier) (result autorest.Response, err error) +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go new file mode 100644 index 000000000000..56724b9202c9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go @@ -0,0 +1,25 @@ +package tables + +import ( + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" +) + +// Client is the base client for Table Storage Shares. +type Client struct { + autorest.Client + BaseURI string +} + +// New creates an instance of the Client client. +func New() Client { + return NewWithEnvironment(azure.PublicCloud) +} + +// NewWithEnvironment creates an instance of the Client client. +func NewWithEnvironment(environment azure.Environment) Client { + return Client{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: environment.StorageEndpointSuffix, + } +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go new file mode 100644 index 000000000000..561f57460daf --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go @@ -0,0 +1,90 @@ +package tables + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type createTableRequest struct { + TableName string `json:"TableName"` +} + +// Create creates a new table in the storage account. +func (client Client) Create(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("tables.Client", "Create", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("tables.Client", "Create", "`tableName` cannot be an empty string.") + } + + req, err := client.CreatePreparer(ctx, accountName, tableName) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "tables.Client", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Create", resp, "Failure responding to request") + return + } + + return +} + +// CreatePreparer prepares the Create request. +func (client Client) CreatePreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + // NOTE: we could support returning metadata here, but it doesn't appear to be directly useful + // vs making a request using the Get methods as-necessary? + "Accept": "application/json;odata=nometadata", + "Prefer": "return-no-content", + } + + body := createTableRequest{ + TableName: tableName, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json"), + autorest.AsPost(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPath("/Tables"), + autorest.WithJSON(body), + autorest.WithHeaders(headers)) + 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 Client) CreateSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go new file mode 100644 index 000000000000..5b5ec86d9ca9 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go @@ -0,0 +1,79 @@ +package tables + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Delete deletes the specified table and any data it contains. +func (client Client) Delete(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("tables.Client", "Delete", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("tables.Client", "Delete", "`tableName` cannot be an empty string.") + } + + req, err := client.DeletePreparer(ctx, accountName, tableName) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "tables.Client", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + } + + // NOTE: whilst the API documentation says that API Version is Optional + // apparently specifying it causes an "invalid content type" to always be returned + // as such we omit it here :shrug: + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/Tables('{tableName}')", pathParameters)) + 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusNoContent), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go new file mode 100644 index 000000000000..b3a271853d82 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go @@ -0,0 +1,80 @@ +package tables + +import ( + "context" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// Exists checks that the specified table exists +func (client Client) Exists(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) { + if accountName == "" { + return result, validation.NewError("tables.Client", "Exists", "`accountName` cannot be an empty string.") + } + if tableName == "" { + return result, validation.NewError("tables.Client", "Exists", "`tableName` cannot be an empty string.") + } + + req, err := client.ExistsPreparer(ctx, accountName, tableName) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Exists", nil, "Failure preparing request") + return + } + + resp, err := client.ExistsSender(req) + if err != nil { + result = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "tables.Client", "Exists", resp, "Failure sending request") + return + } + + result, err = client.ExistsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Exists", resp, "Failure responding to request") + return + } + + return +} + +// ExistsPreparer prepares the Exists request. +func (client Client) ExistsPreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "tableName": autorest.Encode("path", tableName), + } + + // NOTE: whilst the API documentation says that API Version is Optional + // apparently specifying it causes an "invalid content type" to always be returned + // as such we omit it here :shrug: + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.AsContentType("application/xml"), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPathParameters("/Tables('{tableName}')", pathParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ExistsSender sends the Exists request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ExistsSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ExistsResponder handles the response to the Exists request. The method always +// closes the http.Response Body. +func (client Client) ExistsResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go new file mode 100644 index 000000000000..d7c382a53959 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go @@ -0,0 +1,29 @@ +package tables + +type MetaDataLevel string + +var ( + NoMetaData MetaDataLevel = "nometadata" + MinimalMetaData MetaDataLevel = "minimalmetadata" + FullMetaData MetaDataLevel = "fullmetadata" +) + +type GetResultItem struct { + TableName string `json:"TableName"` + + // Optional, depending on the MetaData Level + ODataType string `json:"odata.type,omitempty"` + ODataID string `json:"odata.id,omitEmpty"` + ODataEditLink string `json:"odata.editLink,omitEmpty"` +} + +type SignedIdentifier struct { + Id string `xml:"Id"` + AccessPolicy AccessPolicy `xml:"AccessPolicy"` +} + +type AccessPolicy struct { + Start string `xml:"Start"` + Expiry string `xml:"Expiry"` + Permission string `xml:"Permission"` +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go new file mode 100644 index 000000000000..475370f0cbd5 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go @@ -0,0 +1,87 @@ +package tables + +import ( + "context" + "fmt" + "net/http" + + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +type GetResult struct { + autorest.Response + + MetaData string `json:"odata.metadata,omitempty"` + Tables []GetResultItem `json:"value"` +} + +// Query returns a list of tables under the specified account. +func (client Client) Query(ctx context.Context, accountName string, metaDataLevel MetaDataLevel) (result GetResult, err error) { + if accountName == "" { + return result, validation.NewError("tables.Client", "Query", "`accountName` cannot be an empty string.") + } + + req, err := client.QueryPreparer(ctx, accountName, metaDataLevel) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Query", nil, "Failure preparing request") + return + } + + resp, err := client.QuerySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "tables.Client", "Query", resp, "Failure sending request") + return + } + + result, err = client.QueryResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "tables.Client", "Query", resp, "Failure responding to request") + return + } + + return +} + +// QueryPreparer prepares the Query request. +func (client Client) QueryPreparer(ctx context.Context, accountName string, metaDataLevel MetaDataLevel) (*http.Request, error) { + // NOTE: whilst this supports ContinuationTokens and 'Top' + // it appears that 'Skip' returns a '501 Not Implemented' + // as such, we intentionally don't support those right now + + headers := map[string]interface{}{ + "x-ms-version": APIVersion, + "Accept": fmt.Sprintf("application/json;odata=%s", metaDataLevel), + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), + autorest.WithPath("/Tables"), + autorest.WithHeaders(headers)) + 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 Client) QuerySender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// QueryResponder handles the response to the Query request. The method always +// closes the http.Response Body. +func (client Client) QueryResponder(resp *http.Response) (result GetResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + + return +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go new file mode 100644 index 000000000000..4ceae10150e0 --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go @@ -0,0 +1,54 @@ +package tables + +import ( + "fmt" + "net/url" + "strings" + + "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" +) + +// GetResourceID returns the Resource ID for the given Table +// This can be useful when, for example, you're using this as a unique identifier +func (client Client) GetResourceID(accountName, tableName string) string { + domain := endpoints.GetTableEndpoint(client.BaseURI, accountName) + return fmt.Sprintf("%s/Tables('%s')", domain, tableName) +} + +type ResourceID struct { + AccountName string + TableName string +} + +// ParseResourceID parses the Resource ID and returns an object which +// can be used to interact with the Table within the specified Storage Account +func ParseResourceID(id string) (*ResourceID, error) { + // example: https://foo.table.core.windows.net/Table('foo') + if id == "" { + return nil, fmt.Errorf("`id` was empty") + } + + uri, err := url.Parse(id) + if err != nil { + return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) + } + + accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) + if err != nil { + return nil, fmt.Errorf("Error parsing Account Name: %s", err) + } + + // assume there a `Table('')` + path := strings.TrimPrefix(uri.Path, "/") + if !strings.HasPrefix(path, "Tables('") || !strings.HasSuffix(path, "')") { + return nil, fmt.Errorf("Expected the Table Name to be in the format `Tables('name')` but got %q", path) + } + + // strip off the `Table('')` + tableName := strings.TrimPrefix(uri.Path, "/Tables('") + tableName = strings.TrimSuffix(tableName, "')") + return &ResourceID{ + AccountName: *accountName, + TableName: tableName, + }, nil +} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go new file mode 100644 index 000000000000..05a61a8a7c9d --- /dev/null +++ b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go @@ -0,0 +1,14 @@ +package tables + +import ( + "fmt" + + "github.com/tombuildsstuff/giovanni/version" +) + +// APIVersion is the version of the API used for all Storage API Operations +const APIVersion = "2020-08-04" + +func UserAgent() string { + return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) +} diff --git a/website/docs/r/vmware_authorization.html.markdown b/website/docs/r/vmware_express_route_authorization.html.markdown similarity index 69% rename from website/docs/r/vmware_authorization.html.markdown rename to website/docs/r/vmware_express_route_authorization.html.markdown index f9ac6a62ba05..dca828ecc495 100644 --- a/website/docs/r/vmware_authorization.html.markdown +++ b/website/docs/r/vmware_express_route_authorization.html.markdown @@ -1,14 +1,14 @@ --- subcategory: "VMware (AVS)" layout: "azurerm" -page_title: "Azure Resource Manager: azurerm_vmware_authorization" +page_title: "Azure Resource Manager: azurerm_vmware_express_route_authorization" description: |- - Manages a Vmware Authorization. + Manages an Express Route Vmware Authorization. --- -# azurerm_vmware_authorization +# azurerm_vmware_express_route_authorization -Manages a Vmware Authorization. +Manages an Express Route Vmware Authorization. ## Example Usage @@ -39,7 +39,7 @@ resource "azurerm_vmware_private_cloud" "example" { vcenter_password = "WsxEdc23$Rfv" } -resource "azurerm_vmware_authorization" "example" { +resource "azurerm_vmware_express_route_authorization" "example" { name = "example-authorization" private_cloud_id = azurerm_vmware_private_cloud.example.id } @@ -49,9 +49,9 @@ resource "azurerm_vmware_authorization" "example" { The following arguments are supported: -* `name` - (Required) The name which should be used for this Vmware Authorization. Changing this forces a new Vmware Authorization to be created. +* `name` - (Required) The name which should be used for this Express Route Vmware Authorization. Changing this forces a new Vmware Authorization to be created. -* `private_cloud_id` - (Required) The ID of the Vmware Private Cloud in which to create this Vmware Authorization. Changing this forces a new Vmware Authorization to be created. +* `private_cloud_id` - (Required) The ID of the Vmware Private Cloud in which to create this Express Route Vmware Authorization. Changing this forces a new Vmware Authorization to be created. ## Attributes Reference @@ -76,5 +76,5 @@ The `timeouts` block allows you to specify [timeouts](https://www.terraform.io/d Vmware Authorizations can be imported using the `resource id`, e.g. ```shell -terraform import azurerm_vmware_authorization.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1 -``` \ No newline at end of file +terraform import azurerm_vmware_express_route_authorization.example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.AVS/privateClouds/privateCloud1/authorizations/authorization1 +``` From 9912ff2cba3d42cdda0c73ff44e7912b1c92dc0e Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Mon, 24 May 2021 15:23:56 +0800 Subject: [PATCH 22/23] update --- .../2020-08-04/blob/accounts/README.md | 57 ---- .../2020-08-04/blob/accounts/client.go | 25 -- .../blob/accounts/get_service_properties.go | 84 ----- .../2020-08-04/blob/accounts/models.go | 80 ----- .../blob/accounts/set_service_properties.go | 77 ----- .../2020-08-04/blob/accounts/version.go | 14 - .../storage/2020-08-04/blob/blobs/README.md | 46 --- .../storage/2020-08-04/blob/blobs/api.go | 45 --- .../2020-08-04/blob/blobs/append_block.go | 180 ---------- .../storage/2020-08-04/blob/blobs/client.go | 25 -- .../storage/2020-08-04/blob/blobs/copy.go | 235 ------------- .../2020-08-04/blob/blobs/copy_abort.go | 110 ------- .../2020-08-04/blob/blobs/copy_and_wait.go | 41 --- .../storage/2020-08-04/blob/blobs/delete.go | 105 ------ .../2020-08-04/blob/blobs/delete_snapshot.go | 108 ------ .../2020-08-04/blob/blobs/delete_snapshots.go | 99 ------ .../storage/2020-08-04/blob/blobs/get.go | 116 ------- .../2020-08-04/blob/blobs/get_block_list.go | 140 -------- .../2020-08-04/blob/blobs/get_page_ranges.go | 152 --------- .../blob/blobs/incremental_copy_blob.go | 120 ------- .../2020-08-04/blob/blobs/lease_acquire.go | 135 -------- .../2020-08-04/blob/blobs/lease_break.go | 124 ------- .../2020-08-04/blob/blobs/lease_change.go | 117 ------- .../2020-08-04/blob/blobs/lease_release.go | 98 ------ .../2020-08-04/blob/blobs/lease_renew.go | 97 ------ .../2020-08-04/blob/blobs/metadata_set.go | 113 ------- .../storage/2020-08-04/blob/blobs/models.go | 82 ----- .../2020-08-04/blob/blobs/properties_get.go | 310 ------------------ .../2020-08-04/blob/blobs/properties_set.go | 156 --------- .../2020-08-04/blob/blobs/put_append_blob.go | 134 -------- .../2020-08-04/blob/blobs/put_block.go | 126 ------- .../2020-08-04/blob/blobs/put_block_blob.go | 144 -------- .../blob/blobs/put_block_blob_file.go | 34 -- .../2020-08-04/blob/blobs/put_block_list.go | 157 --------- .../2020-08-04/blob/blobs/put_block_url.go | 129 -------- .../2020-08-04/blob/blobs/put_page_blob.go | 148 --------- .../2020-08-04/blob/blobs/put_page_clear.go | 113 ------- .../2020-08-04/blob/blobs/put_page_update.go | 164 --------- .../2020-08-04/blob/blobs/resource_id.go | 56 ---- .../storage/2020-08-04/blob/blobs/set_tier.go | 93 ------ .../storage/2020-08-04/blob/blobs/snapshot.go | 163 --------- .../blob/blobs/snapshot_get_properties.go | 90 ----- .../storage/2020-08-04/blob/blobs/undelete.go | 92 ------ .../storage/2020-08-04/blob/blobs/version.go | 14 - .../2020-08-04/blob/containers/README.md | 45 --- .../storage/2020-08-04/blob/containers/api.go | 25 -- .../2020-08-04/blob/containers/client.go | 34 -- .../2020-08-04/blob/containers/create.go | 123 ------- .../2020-08-04/blob/containers/delete.go | 85 ----- .../blob/containers/get_properties.go | 124 ------- .../blob/containers/lease_acquire.go | 115 ------- .../2020-08-04/blob/containers/lease_break.go | 129 -------- .../blob/containers/lease_change.go | 111 ------- .../blob/containers/lease_release.go | 92 ------ .../2020-08-04/blob/containers/lease_renew.go | 92 ------ .../2020-08-04/blob/containers/list_blobs.go | 179 ---------- .../2020-08-04/blob/containers/models.go | 75 ----- .../2020-08-04/blob/containers/resource_id.go | 53 --- .../2020-08-04/blob/containers/set_acl.go | 100 ------ .../blob/containers/set_metadata.go | 105 ------ .../2020-08-04/blob/containers/version.go | 14 - .../datalakestore/filesystems/README.md | 84 ----- .../datalakestore/filesystems/client.go | 25 -- .../datalakestore/filesystems/create.go | 94 ------ .../datalakestore/filesystems/delete.go | 85 ----- .../datalakestore/filesystems/helpers.go | 40 --- .../filesystems/properties_get.go | 112 ------- .../filesystems/properties_set.go | 109 ------ .../datalakestore/filesystems/resource_id.go | 46 --- .../datalakestore/filesystems/version.go | 14 - .../2020-08-04/datalakestore/paths/client.go | 25 -- .../2020-08-04/datalakestore/paths/create.go | 95 ------ .../2020-08-04/datalakestore/paths/delete.go | 81 ----- .../2020-08-04/datalakestore/paths/helpers.go | 15 - .../datalakestore/paths/properties_get.go | 134 -------- .../datalakestore/paths/properties_set.go | 116 ------- .../datalakestore/paths/resource_id.go | 57 ---- .../2020-08-04/datalakestore/paths/version.go | 14 - .../2020-08-04/file/directories/README.md | 48 --- .../2020-08-04/file/directories/api.go | 16 - .../2020-08-04/file/directories/client.go | 25 -- .../2020-08-04/file/directories/create.go | 131 -------- .../2020-08-04/file/directories/delete.go | 95 ------ .../2020-08-04/file/directories/get.go | 112 ------- .../file/directories/metadata_get.go | 106 ------ .../file/directories/metadata_set.go | 102 ------ .../file/directories/resource_id.go | 56 ---- .../2020-08-04/file/directories/version.go | 14 - .../storage/2020-08-04/file/files/README.md | 47 --- .../storage/2020-08-04/file/files/api.go | 28 -- .../storage/2020-08-04/file/files/client.go | 25 -- .../storage/2020-08-04/file/files/copy.go | 132 -------- .../2020-08-04/file/files/copy_abort.go | 104 ------ .../2020-08-04/file/files/copy_wait.go | 55 ---- .../storage/2020-08-04/file/files/create.go | 169 ---------- .../storage/2020-08-04/file/files/delete.go | 94 ------ .../2020-08-04/file/files/metadata_get.go | 111 ------- .../2020-08-04/file/files/metadata_set.go | 105 ------ .../2020-08-04/file/files/properties_get.go | 144 -------- .../2020-08-04/file/files/properties_set.go | 186 ----------- .../2020-08-04/file/files/range_clear.go | 112 ------- .../2020-08-04/file/files/range_get.go | 121 ------- .../2020-08-04/file/files/range_get_file.go | 128 -------- .../2020-08-04/file/files/range_put.go | 127 ------- .../2020-08-04/file/files/range_put_file.go | 107 ------ .../2020-08-04/file/files/ranges_list.go | 114 ------- .../2020-08-04/file/files/resource_id.go | 64 ---- .../storage/2020-08-04/file/files/version.go | 14 - .../storage/2020-08-04/file/shares/README.md | 43 --- .../storage/2020-08-04/file/shares/acl_get.go | 98 ------ .../storage/2020-08-04/file/shares/acl_set.go | 103 ------ .../storage/2020-08-04/file/shares/api.go | 24 -- .../storage/2020-08-04/file/shares/client.go | 25 -- .../storage/2020-08-04/file/shares/create.go | 109 ------ .../storage/2020-08-04/file/shares/delete.go | 94 ------ .../2020-08-04/file/shares/metadata_get.go | 102 ------ .../2020-08-04/file/shares/metadata_set.go | 97 ------ .../storage/2020-08-04/file/shares/models.go | 12 - .../2020-08-04/file/shares/properties_get.go | 113 ------- .../2020-08-04/file/shares/properties_set.go | 95 ------ .../2020-08-04/file/shares/resource_id.go | 53 --- .../2020-08-04/file/shares/snapshot_create.go | 115 ------- .../2020-08-04/file/shares/snapshot_delete.go | 94 ------ .../2020-08-04/file/shares/snapshot_get.go | 105 ------ .../storage/2020-08-04/file/shares/stats.go | 100 ------ .../storage/2020-08-04/file/shares/version.go | 14 - .../storage/2020-08-04/queue/queues/README.md | 43 --- .../storage/2020-08-04/queue/queues/api.go | 17 - .../storage/2020-08-04/queue/queues/client.go | 25 -- .../storage/2020-08-04/queue/queues/create.go | 92 ------ .../storage/2020-08-04/queue/queues/delete.go | 85 ----- .../2020-08-04/queue/queues/metadata_get.go | 101 ------ .../2020-08-04/queue/queues/metadata_set.go | 97 ------ .../storage/2020-08-04/queue/queues/models.go | 42 --- .../2020-08-04/queue/queues/properties_get.go | 86 ----- .../2020-08-04/queue/queues/properties_set.go | 81 ----- .../2020-08-04/queue/queues/resource_id.go | 46 --- .../2020-08-04/queue/queues/version.go | 14 - .../2020-08-04/table/entities/README.md | 48 --- .../storage/2020-08-04/table/entities/api.go | 17 - .../2020-08-04/table/entities/client.go | 25 -- .../2020-08-04/table/entities/delete.go | 99 ------ .../storage/2020-08-04/table/entities/get.go | 108 ------ .../2020-08-04/table/entities/insert.go | 112 ------- .../table/entities/insert_or_merge.go | 108 ------ .../table/entities/insert_or_replace.go | 108 ------ .../2020-08-04/table/entities/models.go | 9 - .../2020-08-04/table/entities/query.go | 162 --------- .../2020-08-04/table/entities/resource_id.go | 91 ----- .../2020-08-04/table/entities/version.go | 14 - .../storage/2020-08-04/table/tables/README.md | 39 --- .../2020-08-04/table/tables/acl_get.go | 93 ------ .../2020-08-04/table/tables/acl_set.go | 98 ------ .../storage/2020-08-04/table/tables/api.go | 17 - .../storage/2020-08-04/table/tables/client.go | 25 -- .../storage/2020-08-04/table/tables/create.go | 90 ----- .../storage/2020-08-04/table/tables/delete.go | 79 ----- .../storage/2020-08-04/table/tables/exists.go | 80 ----- .../storage/2020-08-04/table/tables/models.go | 29 -- .../storage/2020-08-04/table/tables/query.go | 87 ----- .../2020-08-04/table/tables/resource_id.go | 54 --- .../2020-08-04/table/tables/version.go | 14 - 162 files changed, 13818 deletions(-) delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go delete mode 100644 vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md deleted file mode 100644 index 5fa24a74e9bb..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/README.md +++ /dev/null @@ -1,57 +0,0 @@ -## Blob Storage Account SDK for API version 2020-08-04 - -This package allows you to interact with the Accounts Blob Storage API - -### Supported Authorizers - -* Azure Active Directory - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts" -) - -func Example() error { - accountName := "storageaccount1" - - // e.g. https://github.com/tombuildsstuff/giovanni/blob/76f5f686c99ecdcc3fa533a0330d0e1aacb1c327/example/azuread-auth/main.go#L54 - client, err := buildClient() - if err != nil { - return fmt.Errorf("error building client: %s", err) - } - - ctx := context.TODO() - - input := StorageServiceProperties{ - StaticWebsite: &StaticWebsite{ - Enabled: true, - IndexDocument: index, - ErrorDocument404Path: errorDocument, - }, - } - - _, err = client.SetServiceProperties(ctx, accountName, input) - if err != nil { - return fmt.Errorf("error setting properties: %s", err) - } - - time.Sleep(2 * time.Second) - - _, err = accountsClient.GetServiceProperties(ctx, accountName) - if err != nil { - return fmt.Errorf("error getting properties: %s", err) - } - - return nil -} - -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go deleted file mode 100644 index 0162ebbb0c33..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package accounts - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Blob Storage Blobs. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithBaseURI creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go deleted file mode 100644 index e622fff3ba46..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/get_service_properties.go +++ /dev/null @@ -1,84 +0,0 @@ -package accounts - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetServicePropertiesResult struct { - autorest.Response - - ContentType string - StorageServiceProperties *StorageServiceProperties -} - -// GetServicePropertiesPreparer prepares the GetServiceProperties request. -func (client Client) GetServicePropertiesPreparer(ctx context.Context, accountName string) (*http.Request, error) { - queryParameters := map[string]interface{}{ - "restype": "service", - "comp": "properties", - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -func (client Client) GetServicePropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -func (client Client) GetServicePropertiesResponder(resp *http.Response) (result GetServicePropertiesResult, err error) { - if resp != nil && resp.Header != nil { - result.ContentType = resp.Header.Get("Content-Type") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result.StorageServiceProperties), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -func (client Client) GetServiceProperties(ctx context.Context, accountName string) (result GetServicePropertiesResult, err error) { - if accountName == "" { - return result, validation.NewError("accounts.Client", "GetServiceProperties", "`accountName` cannot be an empty string.") - } - - req, err := client.GetServicePropertiesPreparer(ctx, accountName) - if err != nil { - err = autorest.NewErrorWithError(err, "accounts.Client", "GetServiceProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetServicePropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "accounts.Client", "GetServiceProperties", resp, "Failure sending request") - return - } - - result, err = client.GetServicePropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "accounts.Client", "GetServiceProperties", resp, "Failure responding to request") - return - } - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go deleted file mode 100644 index 3a2891439bee..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/models.go +++ /dev/null @@ -1,80 +0,0 @@ -package accounts - -import "github.com/Azure/go-autorest/autorest" - -type SetServicePropertiesResult struct { - autorest.Response -} - -type StorageServiceProperties struct { - // Cors - Specifies CORS rules for the Blob service. You can include up to five CorsRule elements in the request. If no CorsRule elements are included in the request body, all CORS rules will be deleted, and CORS will be disabled for the Blob service. - Cors *CorsRules `xml:"Cors,omitempty"` - // DefaultServiceVersion - DefaultServiceVersion indicates the default version to use for requests to the Blob service if an incoming request’s version is not specified. Possible values include version 2008-10-27 and all more recent versions. - DefaultServiceVersion *string `xml:"DefaultServiceVersion,omitempty"` - // DeleteRetentionPolicy - The blob service properties for soft delete. - DeleteRetentionPolicy *DeleteRetentionPolicy `xml:"DeleteRetentionPolicy,omitempty"` - // Logging - The blob service properties for logging access - Logging *Logging `xml:"Logging,omitempty"` - // HourMetrics - The blob service properties for hour metrics - HourMetrics *MetricsConfig `xml:"HourMetrics,omitempty"` - // HourMetrics - The blob service properties for minute metrics - MinuteMetrics *MetricsConfig `xml:"MinuteMetrics,omitempty"` - // StaticWebsite - Optional - StaticWebsite *StaticWebsite `xml:"StaticWebsite,omitempty"` -} - -// StaticWebsite sets the static website support properties on the Blob service. -type StaticWebsite struct { - // Enabled - Required. Indicates whether static website support is enabled for the given account. - Enabled bool `xml:"Enabled"` - // IndexDocument - Optional. The webpage that Azure Storage serves for requests to the root of a website or any subfolder. For example, index.html. The value is case-sensitive. - IndexDocument string `xml:"IndexDocument,omitempty"` - // ErrorDocument404Path - Optional. The absolute path to a webpage that Azure Storage serves for requests that do not correspond to an existing file. For example, error/404.html. Only a single custom 404 page is supported in each static website. The value is case-sensitive. - ErrorDocument404Path string `xml:"ErrorDocument404Path,omitempty"` -} - -// CorsRules sets the CORS rules. You can include up to five CorsRule elements in the request. -type CorsRules struct { - // CorsRules - The List of CORS rules. You can include up to five CorsRule elements in the request. - CorsRules []CorsRule `xml:"CorsRules,omitempty"` -} - -// DeleteRetentionPolicy the blob service properties for soft delete. -type DeleteRetentionPolicy struct { - // Enabled - Indicates whether DeleteRetentionPolicy is enabled for the Blob service. - Enabled bool `xml:"Enabled,omitempty"` - // Days - Indicates the number of days that the deleted blob should be retained. The minimum specified value can be 1 and the maximum value can be 365. - Days int32 `xml:"Days,omitempty"` -} - -// CorsRule specifies a CORS rule for the Blob service. -type CorsRule struct { - // AllowedOrigins - Required if CorsRule element is present. A list of origin domains that will be allowed via CORS, or "" to allow all domains - AllowedOrigins []string `xml:"AllowedOrigins,omitempty"` - // AllowedMethods - Required if CorsRule element is present. A list of HTTP methods that are allowed to be executed by the origin. - AllowedMethods []string `xml:"AllowedMethods,omitempty"` - // MaxAgeInSeconds - Required if CorsRule element is present. The number of seconds that the client/browser should cache a preflight response. - MaxAgeInSeconds int32 `xml:"MaxAgeInSeconds,omitempty"` - // ExposedHeaders - Required if CorsRule element is present. A list of response headers to expose to CORS clients. - ExposedHeaders []string `xml:"ExposedHeaders,omitempty"` - // AllowedHeaders - Required if CorsRule element is present. A list of headers allowed to be part of the cross-origin request. - AllowedHeaders []string `xml:"AllowedHeaders,omitempty"` -} - -// Logging specifies the access logging options for the Blob service. -type Logging struct { - Version string `xml:"Version"` - Delete bool `xml:"Delete"` - Read bool `xml:"Read"` - Write bool `xml:"Write"` - RetentionPolicy DeleteRetentionPolicy `xml:"RetentionPolicy"` -} - -// MetricsConfig specifies the hour and/or minute metrics options for the Blob service. -// Elements are all expected -type MetricsConfig struct { - Version string `xml:"Version"` - Enabled bool `xml:"Enabled"` - RetentionPolicy DeleteRetentionPolicy `xml:"RetentionPolicy"` - IncludeAPIs bool `xml:"IncludeAPIs"` -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go deleted file mode 100644 index 17b7bcc7e763..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/set_service_properties.go +++ /dev/null @@ -1,77 +0,0 @@ -package accounts - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetServicePropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetServicePropertiesPreparer prepares the SetServiceProperties request. -func (client Client) SetServicePropertiesPreparer(ctx context.Context, accountName string, input StorageServiceProperties) (*http.Request, error) { - queryParameters := map[string]interface{}{ - "restype": "service", - "comp": "properties", - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithHeaders(headers), - autorest.WithXML(input), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always -// closes the http.Response Body. -func (client Client) SetServicePropertiesResponder(resp *http.Response) (result SetServicePropertiesResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} - -func (client Client) SetServiceProperties(ctx context.Context, accountName string, input StorageServiceProperties) (result SetServicePropertiesResult, err error) { - if accountName == "" { - return result, validation.NewError("accounts.Client", "SetServiceProperties", "`accountName` cannot be an empty string.") - } - - req, err := client.SetServicePropertiesPreparer(ctx, accountName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "accounts.Client", "SetServiceProperties", nil, "Failure preparing request") - return - } - - resp, err := client.SetServicePropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "accounts.Client", "SetServiceProperties", resp, "Failure sending request") - return - } - - result, err = client.SetServicePropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "accounts.Client", "SetServiceProperties", resp, "Failure responding to request") - return - } - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go deleted file mode 100644 index 3d6d01147003..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/accounts/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package accounts - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md deleted file mode 100644 index 19218cf9fd85..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/README.md +++ /dev/null @@ -1,46 +0,0 @@ -## Blob Storage Blobs SDK for API version 2020-08-04 - -This package allows you to interact with the Blobs Blob Storage API - -### Supported Authorizers - -* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) -* SharedKeyLite (Blob, File & Queue) - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - containerName := "mycontainer" - fileName := "example-large-file.iso" - - storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) - blobClient := blobs.New() - blobClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - copyInput := blobs.CopyInput{ - CopySource: "http://releases.ubuntu.com/14.04/ubuntu-14.04.6-desktop-amd64.iso", - } - refreshInterval := 5 * time.Second - if err := blobClient.CopyAndWait(ctx, accountName, containerName, fileName, copyInput, refreshInterval); err != nil { - return fmt.Errorf("Error copying: %s", err) - } - - return nil -} - -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go deleted file mode 100644 index 7e4f6494c2d1..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/api.go +++ /dev/null @@ -1,45 +0,0 @@ -package blobs - -import ( - "context" - "os" - "time" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageBlob interface { - AppendBlock(ctx context.Context, accountName, containerName, blobName string, input AppendBlockInput) (result AppendBlockResult, err error) - Copy(ctx context.Context, accountName, containerName, blobName string, input CopyInput) (result CopyResult, err error) - AbortCopy(ctx context.Context, accountName, containerName, blobName string, input AbortCopyInput) (result autorest.Response, err error) - CopyAndWait(ctx context.Context, accountName, containerName, blobName string, input CopyInput, pollingInterval time.Duration) error - Delete(ctx context.Context, accountName, containerName, blobName string, input DeleteInput) (result autorest.Response, err error) - DeleteSnapshot(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotInput) (result autorest.Response, err error) - DeleteSnapshots(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotsInput) (result autorest.Response, err error) - Get(ctx context.Context, accountName, containerName, blobName string, input GetInput) (result GetResult, err error) - GetBlockList(ctx context.Context, accountName, containerName, blobName string, input GetBlockListInput) (result GetBlockListResult, err error) - GetPageRanges(ctx context.Context, accountName, containerName, blobName string, input GetPageRangesInput) (result GetPageRangesResult, err error) - IncrementalCopyBlob(ctx context.Context, accountName, containerName, blobName string, input IncrementalCopyBlobInput) (result autorest.Response, err error) - AcquireLease(ctx context.Context, accountName, containerName, blobName string, input AcquireLeaseInput) (result AcquireLeaseResult, err error) - BreakLease(ctx context.Context, accountName, containerName, blobName string, input BreakLeaseInput) (result autorest.Response, err error) - ChangeLease(ctx context.Context, accountName, containerName, blobName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) - ReleaseLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) - RenewLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) - SetMetaData(ctx context.Context, accountName, containerName, blobName string, input SetMetaDataInput) (result autorest.Response, err error) - GetProperties(ctx context.Context, accountName, containerName, blobName string, input GetPropertiesInput) (result GetPropertiesResult, err error) - SetProperties(ctx context.Context, accountName, containerName, blobName string, input SetPropertiesInput) (result SetPropertiesResult, err error) - PutAppendBlob(ctx context.Context, accountName, containerName, blobName string, input PutAppendBlobInput) (result autorest.Response, err error) - PutBlock(ctx context.Context, accountName, containerName, blobName string, input PutBlockInput) (result PutBlockResult, err error) - PutBlockBlob(ctx context.Context, accountName, containerName, blobName string, input PutBlockBlobInput) (result autorest.Response, err error) - PutBlockBlobFromFile(ctx context.Context, accountName, containerName, blobName string, file *os.File, input PutBlockBlobInput) error - PutBlockList(ctx context.Context, accountName, containerName, blobName string, input PutBlockListInput) (result PutBlockListResult, err error) - PutBlockFromURL(ctx context.Context, accountName, containerName, blobName string, input PutBlockFromURLInput) (result PutBlockFromURLResult, err error) - PutPageBlob(ctx context.Context, accountName, containerName, blobName string, input PutPageBlobInput) (result autorest.Response, err error) - PutPageClear(ctx context.Context, accountName, containerName, blobName string, input PutPageClearInput) (result autorest.Response, err error) - PutPageUpdate(ctx context.Context, accountName, containerName, blobName string, input PutPageUpdateInput) (result PutPageUpdateResult, err error) - GetResourceID(accountName, containerName, blobName string) string - SetTier(ctx context.Context, accountName, containerName, blobName string, tier AccessTier) (result autorest.Response, err error) - Snapshot(ctx context.Context, accountName, containerName, blobName string, input SnapshotInput) (result SnapshotResult, err error) - GetSnapshotProperties(ctx context.Context, accountName, containerName, blobName string, input GetSnapshotPropertiesInput) (result GetPropertiesResult, err error) - Undelete(ctx context.Context, accountName, containerName, blobName string) (result autorest.Response, err error) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go deleted file mode 100644 index b7705c202518..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/append_block.go +++ /dev/null @@ -1,180 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strconv" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type AppendBlockInput struct { - - // A number indicating the byte offset to compare. - // Append Block will succeed only if the append position is equal to this number. - // If it is not, the request will fail with an AppendPositionConditionNotMet - // error (HTTP status code 412 – Precondition Failed) - BlobConditionAppendPosition *int64 - - // The max length in bytes permitted for the append blob. - // If the Append Block operation would cause the blob to exceed that limit or if the blob size - // is already greater than the value specified in this header, the request will fail with - // an MaxBlobSizeConditionNotMet error (HTTP status code 412 – Precondition Failed). - BlobConditionMaxSize *int64 - - // The Bytes which should be appended to the end of this Append Blob. - // This can either be nil, which creates an empty blob, or a byte array - Content *[]byte - - // An MD5 hash of the block content. - // This hash is used to verify the integrity of the block during transport. - // When this header is specified, the storage service compares the hash of the content - // that has arrived with this header value. - // - // Note that this MD5 hash is not stored with the blob. - // If the two hashes do not match, the operation will fail with error code 400 (Bad Request). - ContentMD5 *string - - // Required if the blob has an active lease. - // To perform this operation on a blob with an active lease, specify the valid lease ID for this header. - LeaseID *string -} - -type AppendBlockResult struct { - autorest.Response - - BlobAppendOffset string - BlobCommittedBlockCount int64 - ContentMD5 string - ETag string - LastModified string -} - -// AppendBlock commits a new block of data to the end of an existing append blob. -func (client Client) AppendBlock(ctx context.Context, accountName, containerName, blobName string, input AppendBlockInput) (result AppendBlockResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "AppendBlock", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "AppendBlock", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "AppendBlock", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "AppendBlock", "`blobName` cannot be an empty string.") - } - if input.Content != nil && len(*input.Content) > (4*1024*1024) { - return result, validation.NewError("files.Client", "PutByteRange", "`input.Content` must be at most 4MB.") - } - - req, err := client.AppendBlockPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "AppendBlock", nil, "Failure preparing request") - return - } - - resp, err := client.AppendBlockSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "AppendBlock", resp, "Failure sending request") - return - } - - result, err = client.AppendBlockResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "AppendBlock", resp, "Failure responding to request") - return - } - - return -} - -// AppendBlockPreparer prepares the AppendBlock request. -func (client Client) AppendBlockPreparer(ctx context.Context, accountName, containerName, blobName string, input AppendBlockInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "appendblock"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.BlobConditionAppendPosition != nil { - headers["x-ms-blob-condition-appendpos"] = *input.BlobConditionAppendPosition - } - if input.BlobConditionMaxSize != nil { - headers["x-ms-blob-condition-maxsize"] = *input.BlobConditionMaxSize - } - if input.ContentMD5 != nil { - headers["x-ms-blob-content-md5"] = *input.ContentMD5 - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - if input.Content != nil { - headers["Content-Length"] = int(len(*input.Content)) - } - - decorators := []autorest.PrepareDecorator{ - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers), - } - - if input.Content != nil { - decorators = append(decorators, autorest.WithBytes(input.Content)) - } - - preparer := autorest.CreatePreparer(decorators...) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// AppendBlockSender sends the AppendBlock request. The method will close the -// http.Response Body if it receives an error. -func (client Client) AppendBlockSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// AppendBlockResponder handles the response to the AppendBlock request. The method always -// closes the http.Response Body. -func (client Client) AppendBlockResponder(resp *http.Response) (result AppendBlockResult, err error) { - if resp != nil && resp.Header != nil { - result.BlobAppendOffset = resp.Header.Get("x-ms-blob-append-offset") - result.ContentMD5 = resp.Header.Get("ETag") - result.ETag = resp.Header.Get("ETag") - result.LastModified = resp.Header.Get("Last-Modified") - - if v := resp.Header.Get("x-ms-blob-committed-block-count"); v != "" { - i, innerErr := strconv.Atoi(v) - if innerErr != nil { - err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) - return - } - - result.BlobCommittedBlockCount = int64(i) - } - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go deleted file mode 100644 index db20391922bb..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package blobs - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Blob Storage Blobs. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithBaseURI creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go deleted file mode 100644 index febaab5f9a91..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy.go +++ /dev/null @@ -1,235 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type CopyInput struct { - // Specifies the name of the source blob or file. - // Beginning with version 2012-02-12, this value may be a URL of up to 2 KB in length that specifies a blob. - // The value should be URL-encoded as it would appear in a request URI. - // A source blob in the same storage account can be authenticated via Shared Key. - // However, if the source is a blob in another account, - // the source blob must either be public or must be authenticated via a shared access signature. - // If the source blob is public, no authentication is required to perform the copy operation. - // - // Beginning with version 2015-02-21, the source object may be a file in the Azure File service. - // If the source object is a file that is to be copied to a blob, then the source file must be authenticated - // using a shared access signature, whether it resides in the same account or in a different account. - // - // Only storage accounts created on or after June 7th, 2012 allow the Copy Blob operation to - // copy from another storage account. - CopySource string - - // The ID of the Lease - // Required if the destination blob has an active lease. - // The lease ID specified for this header must match the lease ID of the destination blob. - // If the request does not include the lease ID or it is not valid, - // the operation fails with status code 412 (Precondition Failed). - // - // If this header is specified and the destination blob does not currently have an active lease, - // the operation will also fail with status code 412 (Precondition Failed). - LeaseID *string - - // The ID of the Lease on the Source Blob - // Specify to perform the Copy Blob operation only if the lease ID matches the active lease ID of the source blob. - SourceLeaseID *string - - // For page blobs on a premium account only. Specifies the tier to be set on the target blob - AccessTier *AccessTier - - // A user-defined name-value pair associated with the blob. - // If no name-value pairs are specified, the operation will copy the metadata from the source blob or - // file to the destination blob. - // If one or more name-value pairs are specified, the destination blob is created with the specified metadata, - // and metadata is not copied from the source blob or file. - MetaData map[string]string - - // An ETag value. - // Specify an ETag value for this conditional header to copy the blob only if the specified - // ETag value matches the ETag value for an existing destination blob. - // If the ETag for the destination blob does not match the ETag specified for If-Match, - // the Blob service returns status code 412 (Precondition Failed). - IfMatch *string - - // An ETag value, or the wildcard character (*). - // Specify an ETag value for this conditional header to copy the blob only if the specified - // ETag value does not match the ETag value for the destination blob. - // Specify the wildcard character (*) to perform the operation only if the destination blob does not exist. - // If the specified condition isn't met, the Blob service returns status code 412 (Precondition Failed). - IfNoneMatch *string - - // A DateTime value. - // Specify this conditional header to copy the blob only if the destination blob - // has been modified since the specified date/time. - // If the destination blob has not been modified, the Blob service returns status code 412 (Precondition Failed). - IfModifiedSince *string - - // A DateTime value. - // Specify this conditional header to copy the blob only if the destination blob - // has not been modified since the specified date/time. - // If the destination blob has been modified, the Blob service returns status code 412 (Precondition Failed). - IfUnmodifiedSince *string - - // An ETag value. - // Specify this conditional header to copy the source blob only if its ETag matches the value specified. - // If the ETag values do not match, the Blob service returns status code 412 (Precondition Failed). - // This cannot be specified if the source is an Azure File. - SourceIfMatch *string - - // An ETag value. - // Specify this conditional header to copy the blob only if its ETag does not match the value specified. - // If the values are identical, the Blob service returns status code 412 (Precondition Failed). - // This cannot be specified if the source is an Azure File. - SourceIfNoneMatch *string - - // A DateTime value. - // Specify this conditional header to copy the blob only if the source blob has been modified - // since the specified date/time. - // If the source blob has not been modified, the Blob service returns status code 412 (Precondition Failed). - // This cannot be specified if the source is an Azure File. - SourceIfModifiedSince *string - - // A DateTime value. - // Specify this conditional header to copy the blob only if the source blob has not been modified - // since the specified date/time. - // If the source blob has been modified, the Blob service returns status code 412 (Precondition Failed). - // This header cannot be specified if the source is an Azure File. - SourceIfUnmodifiedSince *string -} - -type CopyResult struct { - autorest.Response - - CopyID string - CopyStatus string -} - -// Copy copies a blob to a destination within the storage account asynchronously. -func (client Client) Copy(ctx context.Context, accountName, containerName, blobName string, input CopyInput) (result CopyResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "Copy", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "Copy", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "Copy", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "Copy", "`blobName` cannot be an empty string.") - } - if input.CopySource == "" { - return result, validation.NewError("blobs.Client", "Copy", "`input.CopySource` cannot be an empty string.") - } - - req, err := client.CopyPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Copy", nil, "Failure preparing request") - return - } - - resp, err := client.CopySender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "Copy", resp, "Failure sending request") - return - } - - result, err = client.CopyResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Copy", resp, "Failure responding to request") - return - } - - return -} - -// CopyPreparer prepares the Copy request. -func (client Client) CopyPreparer(ctx context.Context, accountName, containerName, blobName string, input CopyInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-copy-source": autorest.Encode("header", input.CopySource), - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - if input.SourceLeaseID != nil { - headers["x-ms-source-lease-id"] = *input.SourceLeaseID - } - if input.AccessTier != nil { - headers["x-ms-access-tier"] = string(*input.AccessTier) - } - - if input.IfMatch != nil { - headers["If-Match"] = *input.IfMatch - } - if input.IfNoneMatch != nil { - headers["If-None-Match"] = *input.IfNoneMatch - } - if input.IfUnmodifiedSince != nil { - headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince - } - if input.IfModifiedSince != nil { - headers["If-Modified-Since"] = *input.IfModifiedSince - } - - if input.SourceIfMatch != nil { - headers["x-ms-source-if-match"] = *input.SourceIfMatch - } - if input.SourceIfNoneMatch != nil { - headers["x-ms-source-if-none-match"] = *input.SourceIfNoneMatch - } - if input.SourceIfModifiedSince != nil { - headers["x-ms-source-if-modified-since"] = *input.SourceIfModifiedSince - } - if input.SourceIfUnmodifiedSince != nil { - headers["x-ms-source-if-unmodified-since"] = *input.SourceIfUnmodifiedSince - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// CopySender sends the Copy request. The method will close the -// http.Response Body if it receives an error. -func (client Client) CopySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CopyResponder handles the response to the Copy request. The method always -// closes the http.Response Body. -func (client Client) CopyResponder(resp *http.Response) (result CopyResult, err error) { - if resp != nil && resp.Header != nil { - result.CopyID = resp.Header.Get("x-ms-copy-id") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go deleted file mode 100644 index a992ff199bb1..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_abort.go +++ /dev/null @@ -1,110 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type AbortCopyInput struct { - // The Copy ID which should be aborted - CopyID string - - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string -} - -// AbortCopy aborts a pending Copy Blob operation, and leaves a destination blob with zero length and full metadata. -func (client Client) AbortCopy(ctx context.Context, accountName, containerName, blobName string, input AbortCopyInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "AbortCopy", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "AbortCopy", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "AbortCopy", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "AbortCopy", "`blobName` cannot be an empty string.") - } - if input.CopyID == "" { - return result, validation.NewError("blobs.Client", "AbortCopy", "`input.CopyID` cannot be an empty string.") - } - - req, err := client.AbortCopyPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "AbortCopy", nil, "Failure preparing request") - return - } - - resp, err := client.AbortCopySender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "AbortCopy", resp, "Failure sending request") - return - } - - result, err = client.AbortCopyResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "AbortCopy", resp, "Failure responding to request") - return - } - - return -} - -// AbortCopyPreparer prepares the AbortCopy request. -func (client Client) AbortCopyPreparer(ctx context.Context, accountName, containerName, blobName string, input AbortCopyInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "copy"), - "copyid": autorest.Encode("query", input.CopyID), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-copy-action": "abort", - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// AbortCopySender sends the AbortCopy request. The method will close the -// http.Response Body if it receives an error. -func (client Client) AbortCopySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// AbortCopyResponder handles the response to the AbortCopy request. The method always -// closes the http.Response Body. -func (client Client) AbortCopyResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go deleted file mode 100644 index a1e7fa453dc0..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/copy_and_wait.go +++ /dev/null @@ -1,41 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "time" -) - -// CopyAndWait copies a blob to a destination within the storage account and waits for it to finish copying. -func (client Client) CopyAndWait(ctx context.Context, accountName, containerName, blobName string, input CopyInput, pollingInterval time.Duration) error { - if _, err := client.Copy(ctx, accountName, containerName, blobName, input); err != nil { - return fmt.Errorf("Error copying: %s", err) - } - - for true { - getInput := GetPropertiesInput{ - LeaseID: input.LeaseID, - } - getResult, err := client.GetProperties(ctx, accountName, containerName, blobName, getInput) - if err != nil { - return fmt.Errorf("") - } - - switch getResult.CopyStatus { - case Aborted: - return fmt.Errorf("Copy was aborted: %s", getResult.CopyStatusDescription) - - case Failed: - return fmt.Errorf("Copy failed: %s", getResult.CopyStatusDescription) - - case Success: - return nil - - case Pending: - time.Sleep(pollingInterval) - continue - } - } - - return fmt.Errorf("Unexpected error waiting for the copy to complete") -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go deleted file mode 100644 index c1c642d7d781..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete.go +++ /dev/null @@ -1,105 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type DeleteInput struct { - // Should any Snapshots for this Blob also be deleted? - // If the Blob has Snapshots and this is set to False a 409 Conflict will be returned - DeleteSnapshots bool - - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string -} - -// Delete marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection. -func (client Client) Delete(ctx context.Context, accountName, containerName, blobName string, input DeleteInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "Delete", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "Delete", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "Delete", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "Delete", "`blobName` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName, containerName, blobName string, input DeleteInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - if input.DeleteSnapshots { - headers["x-ms-delete-snapshots"] = "include" - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go deleted file mode 100644 index 18c3d4cffe3f..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshot.go +++ /dev/null @@ -1,108 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type DeleteSnapshotInput struct { - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string - - // The DateTime of the Snapshot which should be marked for Deletion - SnapshotDateTime string -} - -// DeleteSnapshot marks a single Snapshot of a Blob for Deletion based on it's DateTime, which will be deleted during the next Garbage Collection cycle. -func (client Client) DeleteSnapshot(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`blobName` cannot be an empty string.") - } - if input.SnapshotDateTime == "" { - return result, validation.NewError("blobs.Client", "DeleteSnapshot", "`input.SnapshotDateTime` cannot be an empty string.") - } - - req, err := client.DeleteSnapshotPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshot", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSnapshotSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshot", resp, "Failure sending request") - return - } - - result, err = client.DeleteSnapshotResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshot", resp, "Failure responding to request") - return - } - - return -} - -// DeleteSnapshotPreparer prepares the DeleteSnapshot request. -func (client Client) DeleteSnapshotPreparer(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "snapshot": autorest.Encode("query", input.SnapshotDateTime), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// DeleteSnapshotSender sends the DeleteSnapshot request. The method will close the -// http.Response Body if it receives an error. -func (client Client) DeleteSnapshotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteSnapshotResponder handles the response to the DeleteSnapshot request. The method always -// closes the http.Response Body. -func (client Client) DeleteSnapshotResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go deleted file mode 100644 index e7e2b664d74d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/delete_snapshots.go +++ /dev/null @@ -1,99 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type DeleteSnapshotsInput struct { - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string -} - -// DeleteSnapshots marks all Snapshots of a Blob for Deletion, which will be deleted during the next Garbage Collection Cycle. -func (client Client) DeleteSnapshots(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotsInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "DeleteSnapshots", "`blobName` cannot be an empty string.") - } - - req, err := client.DeleteSnapshotsPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshots", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSnapshotsSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshots", resp, "Failure sending request") - return - } - - result, err = client.DeleteSnapshotsResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "DeleteSnapshots", resp, "Failure responding to request") - return - } - - return -} - -// DeleteSnapshotsPreparer prepares the DeleteSnapshots request. -func (client Client) DeleteSnapshotsPreparer(ctx context.Context, accountName, containerName, blobName string, input DeleteSnapshotsInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - // only delete the snapshots but leave the blob as-is - "x-ms-delete-snapshots": "only", - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// DeleteSnapshotsSender sends the DeleteSnapshots request. The method will close the -// http.Response Body if it receives an error. -func (client Client) DeleteSnapshotsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteSnapshotsResponder handles the response to the DeleteSnapshots request. The method always -// closes the http.Response Body. -func (client Client) DeleteSnapshotsResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go deleted file mode 100644 index 7e0d6ee9fbd5..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get.go +++ /dev/null @@ -1,116 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetInput struct { - LeaseID *string - StartByte *int64 - EndByte *int64 -} - -type GetResult struct { - autorest.Response - - Contents []byte -} - -// Get reads or downloads a blob from the system, including its metadata and properties. -func (client Client) Get(ctx context.Context, accountName, containerName, blobName string, input GetInput) (result GetResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "Get", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "Get", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "Get", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "Get", "`blobName` cannot be an empty string.") - } - if input.LeaseID != nil && *input.LeaseID == "" { - return result, validation.NewError("blobs.Client", "Get", "`input.LeaseID` should either be specified or nil, not an empty string.") - } - if (input.StartByte != nil && input.EndByte == nil) || input.StartByte == nil && input.EndByte != nil { - return result, validation.NewError("blobs.Client", "Get", "`input.StartByte` and `input.EndByte` must both be specified, or both be nil.") - } - - req, err := client.GetPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Get", nil, "Failure preparing request") - return - } - - resp, err := client.GetSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "Get", resp, "Failure sending request") - return - } - - result, err = client.GetResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Get", resp, "Failure responding to request") - return - } - - return -} - -// GetPreparer prepares the Get request. -func (client Client) GetPreparer(ctx context.Context, accountName, containerName, blobName string, input GetInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.StartByte != nil && input.EndByte != nil { - headers["x-ms-range"] = fmt.Sprintf("bytes=%d-%d", *input.StartByte, *input.EndByte) - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetResponder handles the response to the Get request. The method always -// closes the http.Response Body. -func (client Client) GetResponder(resp *http.Response) (result GetResult, err error) { - if resp != nil && int(resp.ContentLength) > 0 { - result.Contents = make([]byte, resp.ContentLength) - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusPartialContent), - autorest.ByUnmarshallingBytes(&result.Contents), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go deleted file mode 100644 index 9f8120c6c8c3..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_block_list.go +++ /dev/null @@ -1,140 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strconv" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetBlockListInput struct { - BlockListType BlockListType - LeaseID *string -} - -type GetBlockListResult struct { - autorest.Response - - // The size of the blob in bytes - ContentLength *int64 - - // The Content Type of the blob - ContentType string - - // The ETag associated with this blob - ETag string - - // A list of blocks which have been committed - CommittedBlocks CommittedBlocks `xml:"CommittedBlocks,omitempty"` - - // A list of blocks which have not yet been committed - UncommittedBlocks UncommittedBlocks `xml:"UncommittedBlocks,omitempty"` -} - -// GetBlockList retrieves the list of blocks that have been uploaded as part of a block blob. -func (client Client) GetBlockList(ctx context.Context, accountName, containerName, blobName string, input GetBlockListInput) (result GetBlockListResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "GetBlockList", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "GetBlockList", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "GetBlockList", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "GetBlockList", "`blobName` cannot be an empty string.") - } - - req, err := client.GetBlockListPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetBlockList", nil, "Failure preparing request") - return - } - - resp, err := client.GetBlockListSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "GetBlockList", resp, "Failure sending request") - return - } - - result, err = client.GetBlockListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetBlockList", resp, "Failure responding to request") - return - } - - return -} - -// GetBlockListPreparer prepares the GetBlockList request. -func (client Client) GetBlockListPreparer(ctx context.Context, accountName, containerName, blobName string, input GetBlockListInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "blocklisttype": autorest.Encode("query", string(input.BlockListType)), - "comp": autorest.Encode("query", "blocklist"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetBlockListSender sends the GetBlockList request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetBlockListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetBlockListResponder handles the response to the GetBlockList request. The method always -// closes the http.Response Body. -func (client Client) GetBlockListResponder(resp *http.Response) (result GetBlockListResult, err error) { - if resp != nil && resp.Header != nil { - result.ContentType = resp.Header.Get("Content-Type") - result.ETag = resp.Header.Get("ETag") - - if v := resp.Header.Get("x-ms-blob-content-length"); v != "" { - i, innerErr := strconv.Atoi(v) - if innerErr != nil { - err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) - return - } - - i64 := int64(i) - result.ContentLength = &i64 - } - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go deleted file mode 100644 index 37abf631a28a..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/get_page_ranges.go +++ /dev/null @@ -1,152 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strconv" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetPageRangesInput struct { - LeaseID *string - - StartByte *int64 - EndByte *int64 -} - -type GetPageRangesResult struct { - autorest.Response - - // The size of the blob in bytes - ContentLength *int64 - - // The Content Type of the blob - ContentType string - - // The ETag associated with this blob - ETag string - - PageRanges []PageRange `xml:"PageRange"` -} - -type PageRange struct { - // The start byte offset for this range, inclusive - Start int64 `xml:"Start"` - - // The end byte offset for this range, inclusive - End int64 `xml:"End"` -} - -// GetPageRanges returns the list of valid page ranges for a page blob or snapshot of a page blob. -func (client Client) GetPageRanges(ctx context.Context, accountName, containerName, blobName string, input GetPageRangesInput) (result GetPageRangesResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "GetPageRanges", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "GetPageRanges", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "GetPageRanges", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "GetPageRanges", "`blobName` cannot be an empty string.") - } - if (input.StartByte != nil && input.EndByte == nil) || input.StartByte == nil && input.EndByte != nil { - return result, validation.NewError("blobs.Client", "GetPageRanges", "`input.StartByte` and `input.EndByte` must both be specified, or both be nil.") - } - - req, err := client.GetPageRangesPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetPageRanges", nil, "Failure preparing request") - return - } - - resp, err := client.GetPageRangesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "GetPageRanges", resp, "Failure sending request") - return - } - - result, err = client.GetPageRangesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetPageRanges", resp, "Failure responding to request") - return - } - - return -} - -// GetPageRangesPreparer prepares the GetPageRanges request. -func (client Client) GetPageRangesPreparer(ctx context.Context, accountName, containerName, blobName string, input GetPageRangesInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "pagelist"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - if input.StartByte != nil && input.EndByte != nil { - headers["x-ms-range"] = fmt.Sprintf("bytes=%d-%d", *input.StartByte, *input.EndByte) - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetPageRangesSender sends the GetPageRanges request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetPageRangesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetPageRangesResponder handles the response to the GetPageRanges request. The method always -// closes the http.Response Body. -func (client Client) GetPageRangesResponder(resp *http.Response) (result GetPageRangesResult, err error) { - if resp != nil && resp.Header != nil { - result.ContentType = resp.Header.Get("Content-Type") - result.ETag = resp.Header.Get("ETag") - - if v := resp.Header.Get("x-ms-blob-content-length"); v != "" { - i, innerErr := strconv.Atoi(v) - if innerErr != nil { - err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) - return - } - - i64 := int64(i) - result.ContentLength = &i64 - } - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go deleted file mode 100644 index 7fb7e6b55489..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/incremental_copy_blob.go +++ /dev/null @@ -1,120 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type IncrementalCopyBlobInput struct { - CopySource string - IfModifiedSince *string - IfUnmodifiedSince *string - IfMatch *string - IfNoneMatch *string -} - -// IncrementalCopyBlob copies a snapshot of the source page blob to a destination page blob. -// The snapshot is copied such that only the differential changes between the previously copied -// snapshot are transferred to the destination. -// The copied snapshots are complete copies of the original snapshot and can be read or copied from as usual. -func (client Client) IncrementalCopyBlob(ctx context.Context, accountName, containerName, blobName string, input IncrementalCopyBlobInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`blobName` cannot be an empty string.") - } - if input.CopySource == "" { - return result, validation.NewError("blobs.Client", "IncrementalCopyBlob", "`input.CopySource` cannot be an empty string.") - } - - req, err := client.IncrementalCopyBlobPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "IncrementalCopyBlob", nil, "Failure preparing request") - return - } - - resp, err := client.IncrementalCopyBlobSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "IncrementalCopyBlob", resp, "Failure sending request") - return - } - - result, err = client.IncrementalCopyBlobResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "IncrementalCopyBlob", resp, "Failure responding to request") - return - } - - return -} - -// IncrementalCopyBlobPreparer prepares the IncrementalCopyBlob request. -func (client Client) IncrementalCopyBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input IncrementalCopyBlobInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "incrementalcopy"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-copy-source": input.CopySource, - } - - if input.IfModifiedSince != nil { - headers["If-Modified-Since"] = *input.IfModifiedSince - } - if input.IfUnmodifiedSince != nil { - headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince - } - if input.IfMatch != nil { - headers["If-Match"] = *input.IfMatch - } - if input.IfNoneMatch != nil { - headers["If-None-Match"] = *input.IfNoneMatch - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// IncrementalCopyBlobSender sends the IncrementalCopyBlob request. The method will close the -// http.Response Body if it receives an error. -func (client Client) IncrementalCopyBlobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// IncrementalCopyBlobResponder handles the response to the IncrementalCopyBlob request. The method always -// closes the http.Response Body. -func (client Client) IncrementalCopyBlobResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go deleted file mode 100644 index c4b49d73ae71..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_acquire.go +++ /dev/null @@ -1,135 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type AcquireLeaseInput struct { - // The ID of the existing Lease, if leased - LeaseID *string - - // Specifies the duration of the lease, in seconds, or negative one (-1) for a lease that never expires. - // A non-infinite lease can be between 15 and 60 seconds - LeaseDuration int - - // The Proposed new ID for the Lease - ProposedLeaseID *string -} - -type AcquireLeaseResult struct { - autorest.Response - - LeaseID string -} - -// AcquireLease establishes and manages a lock on a blob for write and delete operations. -func (client Client) AcquireLease(ctx context.Context, accountName, containerName, blobName string, input AcquireLeaseInput) (result AcquireLeaseResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "AcquireLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "AcquireLease", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "AcquireLease", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "AcquireLease", "`blobName` cannot be an empty string.") - } - if input.LeaseID != nil && *input.LeaseID == "" { - return result, validation.NewError("blobs.Client", "AcquireLease", "`input.LeaseID` cannot be an empty string, if specified.") - } - if input.ProposedLeaseID != nil && *input.ProposedLeaseID == "" { - return result, validation.NewError("blobs.Client", "AcquireLease", "`input.ProposedLeaseID` cannot be an empty string, if specified.") - } - // An infinite lease duration is -1 seconds. A non-infinite lease can be between 15 and 60 seconds - if input.LeaseDuration != -1 && (input.LeaseDuration <= 15 || input.LeaseDuration >= 60) { - return result, validation.NewError("blobs.Client", "AcquireLease", "`input.LeaseDuration` must be -1 (infinite), or between 15 and 60 seconds.") - } - - req, err := client.AcquireLeasePreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "AcquireLease", nil, "Failure preparing request") - return - } - - resp, err := client.AcquireLeaseSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "AcquireLease", resp, "Failure sending request") - return - } - - result, err = client.AcquireLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "AcquireLease", resp, "Failure responding to request") - return - } - - return -} - -// AcquireLeasePreparer prepares the AcquireLease request. -func (client Client) AcquireLeasePreparer(ctx context.Context, accountName, containerName, blobName string, input AcquireLeaseInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "acquire", - "x-ms-lease-duration": input.LeaseDuration, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - if input.ProposedLeaseID != nil { - headers["x-ms-proposed-lease-id"] = *input.ProposedLeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// AcquireLeaseSender sends the AcquireLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) AcquireLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// AcquireLeaseResponder handles the response to the AcquireLease request. The method always -// closes the http.Response Body. -func (client Client) AcquireLeaseResponder(resp *http.Response) (result AcquireLeaseResult, err error) { - if resp != nil && resp.Header != nil { - result.LeaseID = resp.Header.Get("x-ms-lease-id") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go deleted file mode 100644 index d5642045d20d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_break.go +++ /dev/null @@ -1,124 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type BreakLeaseInput struct { - // For a break operation, proposed duration the lease should continue - // before it is broken, in seconds, between 0 and 60. - // This break period is only used if it is shorter than the time remaining on the lease. - // If longer, the time remaining on the lease is used. - // A new lease will not be available before the break period has expired, - // but the lease may be held for longer than the break period. - // If this header does not appear with a break operation, a fixed-duration lease breaks - // after the remaining lease period elapses, and an infinite lease breaks immediately. - BreakPeriod *int - - LeaseID string -} - -type BreakLeaseResponse struct { - autorest.Response - - // Approximate time remaining in the lease period, in seconds. - // If the break is immediate, 0 is returned. - LeaseTime int -} - -// BreakLease breaks an existing lock on a blob using the LeaseID. -func (client Client) BreakLease(ctx context.Context, accountName, containerName, blobName string, input BreakLeaseInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "BreakLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "BreakLease", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "BreakLease", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "BreakLease", "`blobName` cannot be an empty string.") - } - if input.LeaseID == "" { - return result, validation.NewError("blobs.Client", "BreakLease", "`input.LeaseID` cannot be an empty string.") - } - - req, err := client.BreakLeasePreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "BreakLease", nil, "Failure preparing request") - return - } - - resp, err := client.BreakLeaseSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "BreakLease", resp, "Failure sending request") - return - } - - result, err = client.BreakLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "BreakLease", resp, "Failure responding to request") - return - } - - return -} - -// BreakLeasePreparer prepares the BreakLease request. -func (client Client) BreakLeasePreparer(ctx context.Context, accountName, containerName, blobName string, input BreakLeaseInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "break", - "x-ms-lease-id": input.LeaseID, - } - - if input.BreakPeriod != nil { - headers["x-ms-lease-break-period"] = *input.BreakPeriod - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// BreakLeaseSender sends the BreakLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) BreakLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// BreakLeaseResponder handles the response to the BreakLease request. The method always -// closes the http.Response Body. -func (client Client) BreakLeaseResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go deleted file mode 100644 index c57f9db875b0..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_change.go +++ /dev/null @@ -1,117 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type ChangeLeaseInput struct { - ExistingLeaseID string - ProposedLeaseID string -} - -type ChangeLeaseResponse struct { - autorest.Response - - LeaseID string -} - -// ChangeLease changes an existing lock on a blob for another lock. -func (client Client) ChangeLease(ctx context.Context, accountName, containerName, blobName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "ChangeLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "ChangeLease", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "ChangeLease", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "ChangeLease", "`blobName` cannot be an empty string.") - } - if input.ExistingLeaseID == "" { - return result, validation.NewError("blobs.Client", "ChangeLease", "`input.ExistingLeaseID` cannot be an empty string.") - } - if input.ProposedLeaseID == "" { - return result, validation.NewError("blobs.Client", "ChangeLease", "`input.ProposedLeaseID` cannot be an empty string.") - } - - req, err := client.ChangeLeasePreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "ChangeLease", nil, "Failure preparing request") - return - } - - resp, err := client.ChangeLeaseSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "ChangeLease", resp, "Failure sending request") - return - } - - result, err = client.ChangeLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "ChangeLease", resp, "Failure responding to request") - return - } - - return -} - -// ChangeLeasePreparer prepares the ChangeLease request. -func (client Client) ChangeLeasePreparer(ctx context.Context, accountName, containerName, blobName string, input ChangeLeaseInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "change", - "x-ms-lease-id": input.ExistingLeaseID, - "x-ms-proposed-lease-id": input.ProposedLeaseID, - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ChangeLeaseSender sends the ChangeLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ChangeLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ChangeLeaseResponder handles the response to the ChangeLease request. The method always -// closes the http.Response Body. -func (client Client) ChangeLeaseResponder(resp *http.Response) (result ChangeLeaseResponse, err error) { - if resp != nil && resp.Header != nil { - result.LeaseID = resp.Header.Get("x-ms-lease-id") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go deleted file mode 100644 index 0226cdf37552..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_release.go +++ /dev/null @@ -1,98 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// ReleaseLease releases a lock based on the Lease ID. -func (client Client) ReleaseLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "ReleaseLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "ReleaseLease", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "ReleaseLease", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "ReleaseLease", "`blobName` cannot be an empty string.") - } - if leaseID == "" { - return result, validation.NewError("blobs.Client", "ReleaseLease", "`leaseID` cannot be an empty string.") - } - - req, err := client.ReleaseLeasePreparer(ctx, accountName, containerName, blobName, leaseID) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "ReleaseLease", nil, "Failure preparing request") - return - } - - resp, err := client.ReleaseLeaseSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "ReleaseLease", resp, "Failure sending request") - return - } - - result, err = client.ReleaseLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "ReleaseLease", resp, "Failure responding to request") - return - } - - return -} - -// ReleaseLeasePreparer prepares the ReleaseLease request. -func (client Client) ReleaseLeasePreparer(ctx context.Context, accountName, containerName, blobName, leaseID string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "release", - "x-ms-lease-id": leaseID, - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ReleaseLeaseSender sends the ReleaseLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ReleaseLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ReleaseLeaseResponder handles the response to the ReleaseLease request. The method always -// closes the http.Response Body. -func (client Client) ReleaseLeaseResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go deleted file mode 100644 index 69c495bd9898..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/lease_renew.go +++ /dev/null @@ -1,97 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -func (client Client) RenewLease(ctx context.Context, accountName, containerName, blobName, leaseID string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "RenewLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "RenewLease", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "RenewLease", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "RenewLease", "`blobName` cannot be an empty string.") - } - if leaseID == "" { - return result, validation.NewError("blobs.Client", "RenewLease", "`leaseID` cannot be an empty string.") - } - - req, err := client.RenewLeasePreparer(ctx, accountName, containerName, blobName, leaseID) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "RenewLease", nil, "Failure preparing request") - return - } - - resp, err := client.RenewLeaseSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "RenewLease", resp, "Failure sending request") - return - } - - result, err = client.RenewLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "RenewLease", resp, "Failure responding to request") - return - } - - return -} - -// RenewLeasePreparer prepares the RenewLease request. -func (client Client) RenewLeasePreparer(ctx context.Context, accountName, containerName, blobName, leaseID string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "renew", - "x-ms-lease-id": leaseID, - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// RenewLeaseSender sends the RenewLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) RenewLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// RenewLeaseResponder handles the response to the RenewLease request. The method always -// closes the http.Response Body. -func (client Client) RenewLeaseResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go deleted file mode 100644 index ec69152a5f98..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/metadata_set.go +++ /dev/null @@ -1,113 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type SetMetaDataInput struct { - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string - - // Any metadata which should be added to this blob - MetaData map[string]string -} - -// SetMetaData marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection. -func (client Client) SetMetaData(ctx context.Context, accountName, containerName, blobName string, input SetMetaDataInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "GetProperties", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "GetProperties", "`blobName` cannot be an empty string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("blobs.Client", "GetProperties", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.SetMetaDataPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "SetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.SetMetaDataSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "SetMetaData", resp, "Failure sending request") - return - } - - result, err = client.SetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "SetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// SetMetaDataPreparer prepares the SetMetaData request. -func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, containerName, blobName string, input SetMetaDataInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetMetaDataSender sends the SetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetMetaDataResponder handles the response to the SetMetaData request. The method always -// closes the http.Response Body. -func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go deleted file mode 100644 index d7d83aade8c0..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/models.go +++ /dev/null @@ -1,82 +0,0 @@ -package blobs - -type AccessTier string - -var ( - Archive AccessTier = "Archive" - Cool AccessTier = "Cool" - Hot AccessTier = "Hot" -) - -type ArchiveStatus string - -var ( - None ArchiveStatus = "" - RehydratePendingToCool ArchiveStatus = "rehydrate-pending-to-cool" - RehydratePendingToHot ArchiveStatus = "rehydrate-pending-to-hot" -) - -type BlockListType string - -var ( - All BlockListType = "all" - Committed BlockListType = "committed" - Uncommitted BlockListType = "uncommitted" -) - -type Block struct { - // The base64-encoded Block ID - Name string `xml:"Name"` - - // The size of the Block in Bytes - Size int64 `xml:"Size"` -} - -type BlobType string - -var ( - AppendBlob BlobType = "AppendBlob" - BlockBlob BlobType = "BlockBlob" - PageBlob BlobType = "PageBlob" -) - -type CommittedBlocks struct { - Blocks []Block `xml:"Block"` -} - -type CopyStatus string - -var ( - Aborted CopyStatus = "aborted" - Failed CopyStatus = "failed" - Pending CopyStatus = "pending" - Success CopyStatus = "success" -) - -type LeaseDuration string - -var ( - Fixed LeaseDuration = "fixed" - Infinite LeaseDuration = "infinite" -) - -type LeaseState string - -var ( - Available LeaseState = "available" - Breaking LeaseState = "breaking" - Broken LeaseState = "broken" - Expired LeaseState = "expired" - Leased LeaseState = "leased" -) - -type LeaseStatus string - -var ( - Locked LeaseStatus = "locked" - Unlocked LeaseStatus = "unlocked" -) - -type UncommittedBlocks struct { - Blocks []Block `xml:"Block"` -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go deleted file mode 100644 index 5640687d6d92..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_get.go +++ /dev/null @@ -1,310 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strconv" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetPropertiesInput struct { - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string -} - -type GetPropertiesResult struct { - autorest.Response - - // The tier of page blob on a premium storage account or tier of block blob on blob storage or general purpose v2 account. - AccessTier AccessTier - - // This gives the last time tier was changed on the object. - // This header is returned only if tier on block blob was ever set. - // The date format follows RFC 1123 - AccessTierChangeTime string - - // For page blobs on a premium storage account only. - // If the access tier is not explicitly set on the blob, the tier is inferred based on its content length - // and this header will be returned with true value. - // For block blobs on Blob Storage or general purpose v2 account, if the blob does not have the access tier - // set then we infer the tier from the storage account properties. This header is set only if the block blob - // tier is inferred - AccessTierInferred bool - - // For blob storage or general purpose v2 account. - // If the blob is being rehydrated and is not complete then this header is returned indicating - // that rehydrate is pending and also tells the destination tier - ArchiveStatus ArchiveStatus - - // The number of committed blocks present in the blob. - // This header is returned only for append blobs. - BlobCommittedBlockCount string - - // The current sequence number for a page blob. - // This header is not returned for block blobs or append blobs. - // This header is not returned for block blobs. - BlobSequenceNumber string - - // The blob type. - BlobType BlobType - - // If the Cache-Control request header has previously been set for the blob, that value is returned in this header. - CacheControl string - - // The Content-Disposition response header field conveys additional information about how to process - // the response payload, and also can be used to attach additional metadata. - // For example, if set to attachment, it indicates that the user-agent should not display the response, - // but instead show a Save As dialog. - ContentDisposition string - - // If the Content-Encoding request header has previously been set for the blob, - // that value is returned in this header. - ContentEncoding string - - // If the Content-Language request header has previously been set for the blob, - // that value is returned in this header. - ContentLanguage string - - // The size of the blob in bytes. - // For a page blob, this header returns the value of the x-ms-blob-content-length header stored with the blob. - ContentLength int64 - - // The content type specified for the blob. - // If no content type was specified, the default content type is `application/octet-stream`. - ContentType string - - // If the Content-MD5 header has been set for the blob, this response header is returned so that - // the client can check for message content integrity. - ContentMD5 string - - // Conclusion time of the last attempted Copy Blob operation where this blob was the destination blob. - // This value can specify the time of a completed, aborted, or failed copy attempt. - // This header does not appear if a copy is pending, if this blob has never been the - // destination in a Copy Blob operation, or if this blob has been modified after a concluded Copy Blob - // operation using Set Blob Properties, Put Blob, or Put Block List. - CopyCompletionTime string - - // Included if the blob is incremental copy blob or incremental copy snapshot, if x-ms-copy-status is success. - // Snapshot time of the last successful incremental copy snapshot for this blob - CopyDestinationSnapshot string - - // String identifier for the last attempted Copy Blob operation where this blob was the destination blob. - // This header does not appear if this blob has never been the destination in a Copy Blob operation, - // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, - // Put Blob, or Put Block List. - CopyID string - - // Contains the number of bytes copied and the total bytes in the source in the last attempted - // Copy Blob operation where this blob was the destination blob. - // Can show between 0 and Content-Length bytes copied. - // This header does not appear if this blob has never been the destination in a Copy Blob operation, - // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, - // Put Blob, or Put Block List. - CopyProgress string - - // URL up to 2 KB in length that specifies the source blob used in the last attempted Copy Blob operation - // where this blob was the destination blob. - // This header does not appear if this blob has never been the destination in a Copy Blob operation, - // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, - // Put Blob, or Put Block List - CopySource string - - // State of the copy operation identified by x-ms-copy-id, with these values: - // - success: Copy completed successfully. - // - pending: Copy is in progress. - // Check x-ms-copy-status-description if intermittent, non-fatal errors - // impede copy progress but don’t cause failure. - // - aborted: Copy was ended by Abort Copy Blob. - // - failed: Copy failed. See x-ms- copy-status-description for failure details. - // This header does not appear if this blob has never been the destination in a Copy Blob operation, - // or if this blob has been modified after a completed Copy Blob operation using Set Blob Properties, - // Put Blob, or Put Block List. - CopyStatus CopyStatus - - // Describes cause of fatal or non-fatal copy operation failure. - // This header does not appear if this blob has never been the destination in a Copy Blob operation, - // or if this blob has been modified after a concluded Copy Blob operation using Set Blob Properties, - // Put Blob, or Put Block List. - CopyStatusDescription string - - // The date/time at which the blob was created. The date format follows RFC 1123 - CreationTime string - - // The ETag contains a value that you can use to perform operations conditionally - ETag string - - // Included if the blob is incremental copy blob. - IncrementalCopy bool - - // The date/time that the blob was last modified. The date format follows RFC 1123. - LastModified string - - // When a blob is leased, specifies whether the lease is of infinite or fixed duration - LeaseDuration LeaseDuration - - // The lease state of the blob - LeaseState LeaseState - - LeaseStatus LeaseStatus - - // A set of name-value pairs that correspond to the user-defined metadata associated with this blob - MetaData map[string]string - - // Is the Storage Account encrypted using server-side encryption? This should always return true - ServerEncrypted bool -} - -// GetProperties returns all user-defined metadata, standard HTTP properties, and system properties for the blob -func (client Client) GetProperties(ctx context.Context, accountName, containerName, blobName string, input GetPropertiesInput) (result GetPropertiesResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "GetProperties", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "GetProperties", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "GetProperties", "`blobName` cannot be an empty string.") - } - - req, err := client.GetPropertiesPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetPropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "GetProperties", resp, "Failure sending request") - return - } - - result, err = client.GetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetProperties", resp, "Failure responding to request") - return - } - - return -} - -// GetPropertiesPreparer prepares the GetProperties request. -func (client Client) GetPropertiesPreparer(ctx context.Context, accountName, containerName, blobName string, input GetPropertiesInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsHead(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetPropertiesResponder handles the response to the GetProperties request. The method always -// closes the http.Response Body. -func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResult, err error) { - if resp != nil && resp.Header != nil { - result.AccessTier = AccessTier(resp.Header.Get("x-ms-access-tier")) - result.AccessTierChangeTime = resp.Header.Get(" x-ms-access-tier-change-time") - result.ArchiveStatus = ArchiveStatus(resp.Header.Get(" x-ms-archive-status")) - result.BlobCommittedBlockCount = resp.Header.Get("x-ms-blob-committed-block-count") - result.BlobSequenceNumber = resp.Header.Get("x-ms-blob-sequence-number") - result.BlobType = BlobType(resp.Header.Get("x-ms-blob-type")) - result.CacheControl = resp.Header.Get("Cache-Control") - result.ContentDisposition = resp.Header.Get("Content-Disposition") - result.ContentEncoding = resp.Header.Get("Content-Encoding") - result.ContentLanguage = resp.Header.Get("Content-Language") - result.ContentMD5 = resp.Header.Get("Content-MD5") - result.ContentType = resp.Header.Get("Content-Type") - result.CopyCompletionTime = resp.Header.Get("x-ms-copy-completion-time") - result.CopyDestinationSnapshot = resp.Header.Get("x-ms-copy-destination-snapshot") - result.CopyID = resp.Header.Get("x-ms-copy-id") - result.CopyProgress = resp.Header.Get("x-ms-copy-progress") - result.CopySource = resp.Header.Get("x-ms-copy-source") - result.CopyStatus = CopyStatus(resp.Header.Get("x-ms-copy-status")) - result.CopyStatusDescription = resp.Header.Get("x-ms-copy-status-description") - result.CreationTime = resp.Header.Get("x-ms-creation-time") - result.ETag = resp.Header.Get("Etag") - result.LastModified = resp.Header.Get("Last-Modified") - result.LeaseDuration = LeaseDuration(resp.Header.Get("x-ms-lease-duration")) - result.LeaseState = LeaseState(resp.Header.Get("x-ms-lease-state")) - result.LeaseStatus = LeaseStatus(resp.Header.Get("x-ms-lease-status")) - result.MetaData = metadata.ParseFromHeaders(resp.Header) - - if v := resp.Header.Get("x-ms-access-tier-inferred"); v != "" { - b, innerErr := strconv.ParseBool(v) - if innerErr != nil { - err = fmt.Errorf("Error parsing %q as a bool: %s", v, innerErr) - return - } - - result.AccessTierInferred = b - } - - if v := resp.Header.Get("Content-Length"); v != "" { - i, innerErr := strconv.Atoi(v) - if innerErr != nil { - err = fmt.Errorf("Error parsing %q as an integer: %s", v, innerErr) - } - - result.ContentLength = int64(i) - } - - if v := resp.Header.Get("x-ms-incremental-copy"); v != "" { - b, innerErr := strconv.ParseBool(v) - if innerErr != nil { - err = fmt.Errorf("Error parsing %q as a bool: %s", v, innerErr) - return - } - - result.IncrementalCopy = b - } - - if v := resp.Header.Get("x-ms-server-encrypted"); v != "" { - b, innerErr := strconv.ParseBool(v) - if innerErr != nil { - err = fmt.Errorf("Error parsing %q as a bool: %s", v, innerErr) - return - } - - result.IncrementalCopy = b - } - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go deleted file mode 100644 index a8c0ed8cba95..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/properties_set.go +++ /dev/null @@ -1,156 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type SetPropertiesInput struct { - CacheControl *string - ContentType *string - ContentMD5 *string - ContentEncoding *string - ContentLanguage *string - LeaseID *string - ContentDisposition *string - ContentLength *int64 - SequenceNumberAction *SequenceNumberAction - BlobSequenceNumber *string -} - -type SetPropertiesResult struct { - autorest.Response - - BlobSequenceNumber string - Etag string -} - -// SetProperties sets system properties on the blob. -func (client Client) SetProperties(ctx context.Context, accountName, containerName, blobName string, input SetPropertiesInput) (result SetPropertiesResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "SetProperties", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "SetProperties", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "SetProperties", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "SetProperties", "`blobName` cannot be an empty string.") - } - - req, err := client.SetPropertiesPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "SetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.SetPropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "SetProperties", resp, "Failure sending request") - return - } - - result, err = client.SetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "SetProperties", resp, "Failure responding to request") - return - } - - return -} - -type SequenceNumberAction string - -var ( - Increment SequenceNumberAction = "increment" - Max SequenceNumberAction = "max" - Update SequenceNumberAction = "update" -) - -// SetPropertiesPreparer prepares the SetProperties request. -func (client Client) SetPropertiesPreparer(ctx context.Context, accountName, containerName, blobName string, input SetPropertiesInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "properties"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.CacheControl != nil { - headers["x-ms-blob-cache-control"] = *input.CacheControl - } - if input.ContentDisposition != nil { - headers["x-ms-blob-content-disposition"] = *input.ContentDisposition - } - if input.ContentEncoding != nil { - headers["x-ms-blob-content-encoding"] = *input.ContentEncoding - } - if input.ContentLanguage != nil { - headers["x-ms-blob-content-language"] = *input.ContentLanguage - } - if input.ContentMD5 != nil { - headers["x-ms-blob-content-md5"] = *input.ContentMD5 - } - if input.ContentType != nil { - headers["x-ms-blob-content-type"] = *input.ContentType - } - if input.ContentLength != nil { - headers["x-ms-blob-content-length"] = *input.ContentLength - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - if input.SequenceNumberAction != nil { - headers["x-ms-sequence-number-action"] = string(*input.SequenceNumberAction) - } - if input.BlobSequenceNumber != nil { - headers["x-ms-blob-sequence-number"] = *input.BlobSequenceNumber - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetPropertiesSender sends the SetProperties request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetPropertiesResponder handles the response to the SetProperties request. The method always -// closes the http.Response Body. -func (client Client) SetPropertiesResponder(resp *http.Response) (result SetPropertiesResult, err error) { - if resp != nil && resp.Header != nil { - result.BlobSequenceNumber = resp.Header.Get("x-ms-blob-sequence-number") - result.Etag = resp.Header.Get("Etag") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go deleted file mode 100644 index ef2c5025d606..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_append_blob.go +++ /dev/null @@ -1,134 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type PutAppendBlobInput struct { - CacheControl *string - ContentDisposition *string - ContentEncoding *string - ContentLanguage *string - ContentMD5 *string - ContentType *string - LeaseID *string - MetaData map[string]string -} - -// PutAppendBlob is a wrapper around the Put API call (with a stricter input object) -// which creates a new append blob, or updates the content of an existing blob. -func (client Client) PutAppendBlob(ctx context.Context, accountName, containerName, blobName string, input PutAppendBlobInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutAppendBlob", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutAppendBlob", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutAppendBlob", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutAppendBlob", "`blobName` cannot be an empty string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("blobs.Client", "PutAppendBlob", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.PutAppendBlobPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutAppendBlob", nil, "Failure preparing request") - return - } - - resp, err := client.PutAppendBlobSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutAppendBlob", resp, "Failure sending request") - return - } - - result, err = client.PutAppendBlobResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutAppendBlob", resp, "Failure responding to request") - return - } - - return -} - -// PutAppendBlobPreparer prepares the PutAppendBlob request. -func (client Client) PutAppendBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input PutAppendBlobInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-blob-type": string(AppendBlob), - "x-ms-version": APIVersion, - - // For a page blob or an append blob, the value of this header must be set to zero, - // as Put Blob is used only to initialize the blob - "Content-Length": 0, - } - - if input.CacheControl != nil { - headers["x-ms-blob-cache-control"] = *input.CacheControl - } - if input.ContentDisposition != nil { - headers["x-ms-blob-content-disposition"] = *input.ContentDisposition - } - if input.ContentEncoding != nil { - headers["x-ms-blob-content-encoding"] = *input.ContentEncoding - } - if input.ContentLanguage != nil { - headers["x-ms-blob-content-language"] = *input.ContentLanguage - } - if input.ContentMD5 != nil { - headers["x-ms-blob-content-md5"] = *input.ContentMD5 - } - if input.ContentType != nil { - headers["x-ms-blob-content-type"] = *input.ContentType - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutAppendBlobSender sends the PutAppendBlob request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutAppendBlobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutAppendBlobResponder handles the response to the PutAppendBlob request. The method always -// closes the http.Response Body. -func (client Client) PutAppendBlobResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go deleted file mode 100644 index 6d41bda13b55..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block.go +++ /dev/null @@ -1,126 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type PutBlockInput struct { - BlockID string - Content []byte - ContentMD5 *string - LeaseID *string -} - -type PutBlockResult struct { - autorest.Response - - ContentMD5 string -} - -// PutBlock creates a new block to be committed as part of a blob. -func (client Client) PutBlock(ctx context.Context, accountName, containerName, blobName string, input PutBlockInput) (result PutBlockResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutBlock", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutBlock", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutBlock", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutBlock", "`blobName` cannot be an empty string.") - } - if input.BlockID == "" { - return result, validation.NewError("blobs.Client", "PutBlock", "`input.BlockID` cannot be an empty string.") - } - if len(input.Content) == 0 { - return result, validation.NewError("blobs.Client", "PutBlock", "`input.Content` cannot be empty.") - } - - req, err := client.PutBlockPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlock", nil, "Failure preparing request") - return - } - - resp, err := client.PutBlockSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlock", resp, "Failure sending request") - return - } - - result, err = client.PutBlockResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlock", resp, "Failure responding to request") - return - } - - return -} - -// PutBlockPreparer prepares the PutBlock request. -func (client Client) PutBlockPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "block"), - "blockid": autorest.Encode("query", input.BlockID), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "Content-Length": int(len(input.Content)), - } - - if input.ContentMD5 != nil { - headers["x-ms-blob-content-md5"] = *input.ContentMD5 - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers), - autorest.WithBytes(&input.Content)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutBlockSender sends the PutBlock request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutBlockSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutBlockResponder handles the response to the PutBlock request. The method always -// closes the http.Response Body. -func (client Client) PutBlockResponder(resp *http.Response) (result PutBlockResult, err error) { - if resp != nil && resp.Header != nil { - result.ContentMD5 = resp.Header.Get("Content-MD5") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go deleted file mode 100644 index f5c1a971b306..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob.go +++ /dev/null @@ -1,144 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type PutBlockBlobInput struct { - CacheControl *string - Content *[]byte - ContentDisposition *string - ContentEncoding *string - ContentLanguage *string - ContentMD5 *string - ContentType *string - LeaseID *string - MetaData map[string]string -} - -// PutBlockBlob is a wrapper around the Put API call (with a stricter input object) -// which creates a new block append blob, or updates the content of an existing block blob. -func (client Client) PutBlockBlob(ctx context.Context, accountName, containerName, blobName string, input PutBlockBlobInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutBlockBlob", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutBlockBlob", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutBlockBlob", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutBlockBlob", "`blobName` cannot be an empty string.") - } - if input.Content != nil && len(*input.Content) == 0 { - return result, validation.NewError("blobs.Client", "PutBlockBlob", "`input.Content` must either be nil or not empty.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("blobs.Client", "PutBlockBlob", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.PutBlockBlobPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockBlob", nil, "Failure preparing request") - return - } - - resp, err := client.PutBlockBlobSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockBlob", resp, "Failure sending request") - return - } - - result, err = client.PutBlockBlobResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockBlob", resp, "Failure responding to request") - return - } - - return -} - -// PutBlockBlobPreparer prepares the PutBlockBlob request. -func (client Client) PutBlockBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockBlobInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-blob-type": string(BlockBlob), - "x-ms-version": APIVersion, - } - - if input.CacheControl != nil { - headers["x-ms-blob-cache-control"] = *input.CacheControl - } - if input.ContentDisposition != nil { - headers["x-ms-blob-content-disposition"] = *input.ContentDisposition - } - if input.ContentEncoding != nil { - headers["x-ms-blob-content-encoding"] = *input.ContentEncoding - } - if input.ContentLanguage != nil { - headers["x-ms-blob-content-language"] = *input.ContentLanguage - } - if input.ContentMD5 != nil { - headers["x-ms-blob-content-md5"] = *input.ContentMD5 - } - if input.ContentType != nil { - headers["x-ms-blob-content-type"] = *input.ContentType - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - if input.Content != nil { - headers["Content-Length"] = int(len(*input.Content)) - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - decorators := []autorest.PrepareDecorator{ - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - } - - if input.Content != nil { - decorators = append(decorators, autorest.WithBytes(input.Content)) - } - - preparer := autorest.CreatePreparer(decorators...) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutBlockBlobSender sends the PutBlockBlob request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutBlockBlobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutBlockBlobResponder handles the response to the PutBlockBlob request. The method always -// closes the http.Response Body. -func (client Client) PutBlockBlobResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go deleted file mode 100644 index b7499498aeca..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_blob_file.go +++ /dev/null @@ -1,34 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "io" - "os" -) - -// PutBlockBlobFromFile is a helper method which takes a file, and automatically chunks it up, rather than having to do this yourself -func (client Client) PutBlockBlobFromFile(ctx context.Context, accountName, containerName, blobName string, file *os.File, input PutBlockBlobInput) error { - fileInfo, err := file.Stat() - if err != nil { - return fmt.Errorf("Error loading file info: %s", err) - } - - fileSize := fileInfo.Size() - bytes := make([]byte, fileSize) - - _, err = file.ReadAt(bytes, 0) - if err != nil { - if err != io.EOF { - return fmt.Errorf("Error reading bytes: %s", err) - } - } - - input.Content = &bytes - - if _, err = client.PutBlockBlob(ctx, accountName, containerName, blobName, input); err != nil { - return fmt.Errorf("Error putting bytes: %s", err) - } - - return nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go deleted file mode 100644 index f80524790be5..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_list.go +++ /dev/null @@ -1,157 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type BlockList struct { - CommittedBlockIDs []BlockID `xml:"Committed,omitempty"` - UncommittedBlockIDs []BlockID `xml:"Uncommitted,omitempty"` - LatestBlockIDs []BlockID `xml:"Latest,omitempty"` -} - -type BlockID struct { - Value string `xml:",chardata"` -} - -type PutBlockListInput struct { - BlockList BlockList - CacheControl *string - ContentDisposition *string - ContentEncoding *string - ContentLanguage *string - ContentMD5 *string - ContentType *string - MetaData map[string]string - LeaseID *string -} - -type PutBlockListResult struct { - autorest.Response - - ContentMD5 string - ETag string - LastModified string -} - -// PutBlockList writes a blob by specifying the list of block IDs that make up the blob. -// In order to be written as part of a blob, a block must have been successfully written -// to the server in a prior Put Block operation. -func (client Client) PutBlockList(ctx context.Context, accountName, containerName, blobName string, input PutBlockListInput) (result PutBlockListResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutBlockList", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutBlockList", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutBlockList", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutBlockList", "`blobName` cannot be an empty string.") - } - - req, err := client.PutBlockListPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockList", nil, "Failure preparing request") - return - } - - resp, err := client.PutBlockListSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockList", resp, "Failure sending request") - return - } - - result, err = client.PutBlockListResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockList", resp, "Failure responding to request") - return - } - - return -} - -// PutBlockListPreparer prepares the PutBlockList request. -func (client Client) PutBlockListPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockListInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "blocklist"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.CacheControl != nil { - headers["x-ms-blob-cache-control"] = *input.CacheControl - } - if input.ContentDisposition != nil { - headers["x-ms-blob-content-disposition"] = *input.ContentDisposition - } - if input.ContentEncoding != nil { - headers["x-ms-blob-content-encoding"] = *input.ContentEncoding - } - if input.ContentLanguage != nil { - headers["x-ms-blob-content-language"] = *input.ContentLanguage - } - if input.ContentMD5 != nil { - headers["x-ms-blob-content-md5"] = *input.ContentMD5 - } - if input.ContentType != nil { - headers["x-ms-blob-content-type"] = *input.ContentType - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers), - autorest.WithXML(input.BlockList)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutBlockListSender sends the PutBlockList request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutBlockListSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutBlockListResponder handles the response to the PutBlockList request. The method always -// closes the http.Response Body. -func (client Client) PutBlockListResponder(resp *http.Response) (result PutBlockListResult, err error) { - if resp != nil && resp.Header != nil { - result.ContentMD5 = resp.Header.Get("Content-MD5") - result.ETag = resp.Header.Get("ETag") - result.LastModified = resp.Header.Get("Last-Modified") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go deleted file mode 100644 index 95ad974698bd..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_block_url.go +++ /dev/null @@ -1,129 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type PutBlockFromURLInput struct { - BlockID string - CopySource string - - ContentMD5 *string - LeaseID *string - Range *string -} - -type PutBlockFromURLResult struct { - autorest.Response - ContentMD5 string -} - -// PutBlockFromURL creates a new block to be committed as part of a blob where the contents are read from a URL -func (client Client) PutBlockFromURL(ctx context.Context, accountName, containerName, blobName string, input PutBlockFromURLInput) (result PutBlockFromURLResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`blobName` cannot be an empty string.") - } - if input.BlockID == "" { - return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`input.BlockID` cannot be an empty string.") - } - if input.CopySource == "" { - return result, validation.NewError("blobs.Client", "PutBlockFromURL", "`input.CopySource` cannot be an empty string.") - } - - req, err := client.PutBlockFromURLPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockFromURL", nil, "Failure preparing request") - return - } - - resp, err := client.PutBlockFromURLSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockFromURL", resp, "Failure sending request") - return - } - - result, err = client.PutBlockFromURLResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutBlockFromURL", resp, "Failure responding to request") - return - } - - return -} - -// PutBlockFromURLPreparer prepares the PutBlockFromURL request. -func (client Client) PutBlockFromURLPreparer(ctx context.Context, accountName, containerName, blobName string, input PutBlockFromURLInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "block"), - "blockid": autorest.Encode("query", input.BlockID), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-copy-source": input.CopySource, - } - - if input.ContentMD5 != nil { - headers["x-ms-source-content-md5"] = *input.ContentMD5 - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - if input.Range != nil { - headers["x-ms-source-range"] = *input.Range - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutBlockFromURLSender sends the PutBlockFromURL request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutBlockFromURLSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutBlockFromURLResponder handles the response to the PutBlockFromURL request. The method always -// closes the http.Response Body. -func (client Client) PutBlockFromURLResponder(resp *http.Response) (result PutBlockFromURLResult, err error) { - if resp != nil && resp.Header != nil { - result.ContentMD5 = resp.Header.Get("Content-MD5") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go deleted file mode 100644 index 4cfba95ae37b..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_blob.go +++ /dev/null @@ -1,148 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type PutPageBlobInput struct { - CacheControl *string - ContentDisposition *string - ContentEncoding *string - ContentLanguage *string - ContentMD5 *string - ContentType *string - LeaseID *string - MetaData map[string]string - - BlobContentLengthBytes int64 - BlobSequenceNumber *int64 - AccessTier *AccessTier -} - -// PutPageBlob is a wrapper around the Put API call (with a stricter input object) -// which creates a new block blob, or updates the content of an existing page blob. -func (client Client) PutPageBlob(ctx context.Context, accountName, containerName, blobName string, input PutPageBlobInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutPageBlob", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutPageBlob", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutPageBlob", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutPageBlob", "`blobName` cannot be an empty string.") - } - if input.BlobContentLengthBytes == 0 || input.BlobContentLengthBytes%512 != 0 { - return result, validation.NewError("blobs.Client", "PutPageBlob", "`input.BlobContentLengthBytes` must be aligned to a 512-byte boundary.") - } - - req, err := client.PutPageBlobPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageBlob", nil, "Failure preparing request") - return - } - - resp, err := client.PutPageBlobSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageBlob", resp, "Failure sending request") - return - } - - result, err = client.PutPageBlobResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageBlob", resp, "Failure responding to request") - return - } - - return -} - -// PutPageBlobPreparer prepares the PutPageBlob request. -func (client Client) PutPageBlobPreparer(ctx context.Context, accountName, containerName, blobName string, input PutPageBlobInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - headers := map[string]interface{}{ - "x-ms-blob-type": string(PageBlob), - "x-ms-version": APIVersion, - - // For a page blob or an page blob, the value of this header must be set to zero, - // as Put Blob is used only to initialize the blob - "Content-Length": 0, - - // This header specifies the maximum size for the page blob, up to 8 TB. - // The page blob size must be aligned to a 512-byte boundary. - "x-ms-blob-content-length": input.BlobContentLengthBytes, - } - - if input.AccessTier != nil { - headers["x-ms-access-tier"] = string(*input.AccessTier) - } - if input.BlobSequenceNumber != nil { - headers["x-ms-blob-sequence-number"] = *input.BlobSequenceNumber - } - - if input.CacheControl != nil { - headers["x-ms-blob-cache-control"] = *input.CacheControl - } - if input.ContentDisposition != nil { - headers["x-ms-blob-content-disposition"] = *input.ContentDisposition - } - if input.ContentEncoding != nil { - headers["x-ms-blob-content-encoding"] = *input.ContentEncoding - } - if input.ContentLanguage != nil { - headers["x-ms-blob-content-language"] = *input.ContentLanguage - } - if input.ContentMD5 != nil { - headers["x-ms-blob-content-md5"] = *input.ContentMD5 - } - if input.ContentType != nil { - headers["x-ms-blob-content-type"] = *input.ContentType - } - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutPageBlobSender sends the PutPageBlob request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutPageBlobSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutPageBlobResponder handles the response to the PutPageBlob request. The method always -// closes the http.Response Body. -func (client Client) PutPageBlobResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go deleted file mode 100644 index 59feaa5d93d0..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_clear.go +++ /dev/null @@ -1,113 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type PutPageClearInput struct { - StartByte int64 - EndByte int64 - - LeaseID *string -} - -// PutPageClear clears a range of pages within a page blob. -func (client Client) PutPageClear(ctx context.Context, accountName, containerName, blobName string, input PutPageClearInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutPageClear", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutPageClear", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutPageClear", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutPageClear", "`blobName` cannot be an empty string.") - } - if input.StartByte < 0 { - return result, validation.NewError("blobs.Client", "PutPageClear", "`input.StartByte` must be greater than or equal to 0.") - } - if input.EndByte <= 0 { - return result, validation.NewError("blobs.Client", "PutPageClear", "`input.EndByte` must be greater than 0.") - } - - req, err := client.PutPageClearPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageClear", nil, "Failure preparing request") - return - } - - resp, err := client.PutPageClearSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageClear", resp, "Failure sending request") - return - } - - result, err = client.PutPageClearResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageClear", resp, "Failure responding to request") - return - } - - return -} - -// PutPageClearPreparer prepares the PutPageClear request. -func (client Client) PutPageClearPreparer(ctx context.Context, accountName, containerName, blobName string, input PutPageClearInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "page"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-page-write": "clear", - "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartByte, input.EndByte), - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutPageClearSender sends the PutPageClear request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutPageClearSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutPageClearResponder handles the response to the PutPageClear request. The method always -// closes the http.Response Body. -func (client Client) PutPageClearResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go deleted file mode 100644 index 3799381e5525..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/put_page_update.go +++ /dev/null @@ -1,164 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type PutPageUpdateInput struct { - StartByte int64 - EndByte int64 - Content []byte - - IfSequenceNumberEQ *string - IfSequenceNumberLE *string - IfSequenceNumberLT *string - IfModifiedSince *string - IfUnmodifiedSince *string - IfMatch *string - IfNoneMatch *string - LeaseID *string -} - -type PutPageUpdateResult struct { - autorest.Response - - BlobSequenceNumber string - ContentMD5 string - LastModified string -} - -// PutPageUpdate writes a range of pages to a page blob. -func (client Client) PutPageUpdate(ctx context.Context, accountName, containerName, blobName string, input PutPageUpdateInput) (result PutPageUpdateResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "PutPageUpdate", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "PutPageUpdate", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "PutPageUpdate", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "PutPageUpdate", "`blobName` cannot be an empty string.") - } - if input.StartByte < 0 { - return result, validation.NewError("blobs.Client", "PutPageUpdate", "`input.StartByte` must be greater than or equal to 0.") - } - if input.EndByte <= 0 { - return result, validation.NewError("blobs.Client", "PutPageUpdate", "`input.EndByte` must be greater than 0.") - } - - expectedSize := (input.EndByte - input.StartByte) + 1 - actualSize := int64(len(input.Content)) - if expectedSize != actualSize { - return result, validation.NewError("blobs.Client", "PutPageUpdate", fmt.Sprintf("Content Size was defined as %d but got %d.", expectedSize, actualSize)) - } - - req, err := client.PutPageUpdatePreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageUpdate", nil, "Failure preparing request") - return - } - - resp, err := client.PutPageUpdateSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageUpdate", resp, "Failure sending request") - return - } - - result, err = client.PutPageUpdateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "PutPageUpdate", resp, "Failure responding to request") - return - } - - return -} - -// PutPageUpdatePreparer prepares the PutPageUpdate request. -func (client Client) PutPageUpdatePreparer(ctx context.Context, accountName, containerName, blobName string, input PutPageUpdateInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "page"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-page-write": "update", - "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartByte, input.EndByte), - "Content-Length": int(len(input.Content)), - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - if input.IfSequenceNumberEQ != nil { - headers["x-ms-if-sequence-number-eq"] = *input.IfSequenceNumberEQ - } - if input.IfSequenceNumberLE != nil { - headers["x-ms-if-sequence-number-le"] = *input.IfSequenceNumberLE - } - if input.IfSequenceNumberLT != nil { - headers["x-ms-if-sequence-number-lt"] = *input.IfSequenceNumberLT - } - if input.IfModifiedSince != nil { - headers["If-Modified-Since"] = *input.IfModifiedSince - } - if input.IfUnmodifiedSince != nil { - headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince - } - if input.IfMatch != nil { - headers["If-Match"] = *input.IfMatch - } - if input.IfNoneMatch != nil { - headers["If-None-Match"] = *input.IfNoneMatch - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers), - autorest.WithBytes(&input.Content)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutPageUpdateSender sends the PutPageUpdate request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutPageUpdateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutPageUpdateResponder handles the response to the PutPageUpdate request. The method always -// closes the http.Response Body. -func (client Client) PutPageUpdateResponder(resp *http.Response) (result PutPageUpdateResult, err error) { - if resp != nil && resp.Header != nil { - result.BlobSequenceNumber = resp.Header.Get("x-ms-blob-sequence-number") - result.ContentMD5 = resp.Header.Get("Content-MD5") - result.LastModified = resp.Header.Get("Last-Modified") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go deleted file mode 100644 index 4057cf275676..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/resource_id.go +++ /dev/null @@ -1,56 +0,0 @@ -package blobs - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Blob -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, containerName, blobName string) string { - domain := endpoints.GetBlobEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s/%s", domain, containerName, blobName) -} - -type ResourceID struct { - AccountName string - ContainerName string - BlobName string -} - -// ParseResourceID parses the Resource ID and returns an object which can be used -// to interact with the Blob Resource -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.blob.core.windows.net/Bar/example.vhd - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - path := strings.TrimPrefix(uri.Path, "/") - segments := strings.Split(path, "/") - if len(segments) == 0 { - return nil, fmt.Errorf("Expected the path to contain segments but got none") - } - - containerName := segments[0] - blobName := strings.TrimPrefix(path, containerName) - blobName = strings.TrimPrefix(blobName, "/") - return &ResourceID{ - AccountName: *accountName, - ContainerName: containerName, - BlobName: blobName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go deleted file mode 100644 index dd0f0b8782b1..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/set_tier.go +++ /dev/null @@ -1,93 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// SetTier sets the tier on a blob. -func (client Client) SetTier(ctx context.Context, accountName, containerName, blobName string, tier AccessTier) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "SetTier", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "SetTier", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "SetTier", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "SetTier", "`blobName` cannot be an empty string.") - } - - req, err := client.SetTierPreparer(ctx, accountName, containerName, blobName, tier) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "SetTier", nil, "Failure preparing request") - return - } - - resp, err := client.SetTierSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "SetTier", resp, "Failure sending request") - return - } - - result, err = client.SetTierResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "SetTier", resp, "Failure responding to request") - return - } - - return -} - -// SetTierPreparer prepares the SetTier request. -func (client Client) SetTierPreparer(ctx context.Context, accountName, containerName, blobName string, tier AccessTier) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "tier"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-access-tier": string(tier), - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetTierSender sends the SetTier request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetTierSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetTierResponder handles the response to the SetTier request. The method always -// closes the http.Response Body. -func (client Client) SetTierResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go deleted file mode 100644 index 180070b29469..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot.go +++ /dev/null @@ -1,163 +0,0 @@ -package blobs - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type SnapshotInput struct { - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string - - // MetaData is a user-defined name-value pair associated with the blob. - // If no name-value pairs are specified, the operation will copy the base blob metadata to the snapshot. - // If one or more name-value pairs are specified, the snapshot is created with the specified metadata, - // and metadata is not copied from the base blob. - MetaData map[string]string - - // A DateTime value which will only snapshot the blob if it has been modified since the specified date/time - // If the base blob has not been modified, the Blob service returns status code 412 (Precondition Failed). - IfModifiedSince *string - - // A DateTime value which will only snapshot the blob if it has not been modified since the specified date/time - // If the base blob has been modified, the Blob service returns status code 412 (Precondition Failed). - IfUnmodifiedSince *string - - // An ETag value to snapshot the blob only if its ETag value matches the value specified. - // If the values do not match, the Blob service returns status code 412 (Precondition Failed). - IfMatch *string - - // An ETag value for this conditional header to snapshot the blob only if its ETag value - // does not match the value specified. - // If the values are identical, the Blob service returns status code 412 (Precondition Failed). - IfNoneMatch *string -} - -type SnapshotResult struct { - autorest.Response - - // The ETag of the snapshot - ETag string - - // A DateTime value that uniquely identifies the snapshot. - // The value of this header indicates the snapshot version, - // and may be used in subsequent requests to access the snapshot. - SnapshotDateTime string -} - -// Snapshot captures a Snapshot of a given Blob -func (client Client) Snapshot(ctx context.Context, accountName, containerName, blobName string, input SnapshotInput) (result SnapshotResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "Snapshot", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "Snapshot", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "Snapshot", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "Snapshot", "`blobName` cannot be an empty string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("blobs.Client", "Snapshot", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.SnapshotPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Snapshot", nil, "Failure preparing request") - return - } - - resp, err := client.SnapshotSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "Snapshot", resp, "Failure sending request") - return - } - - result, err = client.SnapshotResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Snapshot", resp, "Failure responding to request") - return - } - - return -} - -// SnapshotPreparer prepares the Snapshot request. -func (client Client) SnapshotPreparer(ctx context.Context, accountName, containerName, blobName string, input SnapshotInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "snapshot"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - if input.IfModifiedSince != nil { - headers["If-Modified-Since"] = *input.IfModifiedSince - } - if input.IfUnmodifiedSince != nil { - headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince - } - if input.IfMatch != nil { - headers["If-Match"] = *input.IfMatch - } - if input.IfNoneMatch != nil { - headers["If-None-Match"] = *input.IfNoneMatch - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SnapshotSender sends the Snapshot request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SnapshotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SnapshotResponder handles the response to the Snapshot request. The method always -// closes the http.Response Body. -func (client Client) SnapshotResponder(resp *http.Response) (result SnapshotResult, err error) { - if resp != nil && resp.Header != nil { - result.ETag = resp.Header.Get("ETag") - result.SnapshotDateTime = resp.Header.Get("x-ms-snapshot") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go deleted file mode 100644 index fe1be63ab216..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/snapshot_get_properties.go +++ /dev/null @@ -1,90 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetSnapshotPropertiesInput struct { - // The ID of the Lease - // This must be specified if a Lease is present on the Blob, else a 403 is returned - LeaseID *string - - // The ID of the Snapshot which should be retrieved - SnapshotID string -} - -// GetSnapshotProperties returns all user-defined metadata, standard HTTP properties, and system properties for -// the specified snapshot of a blob -func (client Client) GetSnapshotProperties(ctx context.Context, accountName, containerName, blobName string, input GetSnapshotPropertiesInput) (result GetPropertiesResult, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`blobName` cannot be an empty string.") - } - if input.SnapshotID == "" { - return result, validation.NewError("blobs.Client", "GetSnapshotProperties", "`input.SnapshotID` cannot be an empty string.") - } - - req, err := client.GetSnapshotPropertiesPreparer(ctx, accountName, containerName, blobName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetSnapshotProperties", nil, "Failure preparing request") - return - } - - // we re-use the GetProperties methods since this is otherwise the same - resp, err := client.GetPropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "GetSnapshotProperties", resp, "Failure sending request") - return - } - - result, err = client.GetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "GetSnapshotProperties", resp, "Failure responding to request") - return - } - - return -} - -// GetSnapshotPreparer prepares the GetSnapshot request. -func (client Client) GetSnapshotPropertiesPreparer(ctx context.Context, accountName, containerName, blobName string, input GetSnapshotPropertiesInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "snapshot": autorest.Encode("query", input.SnapshotID), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.LeaseID != nil { - headers["x-ms-lease-id"] = *input.LeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsHead(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go deleted file mode 100644 index 9be2f81a66f2..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/undelete.go +++ /dev/null @@ -1,92 +0,0 @@ -package blobs - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Undelete restores the contents and metadata of soft deleted blob and any associated soft deleted snapshots. -func (client Client) Undelete(ctx context.Context, accountName, containerName, blobName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("blobs.Client", "Undelete", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("blobs.Client", "Undelete", "`containerName` cannot be an empty string.") - } - if strings.ToLower(containerName) != containerName { - return result, validation.NewError("blobs.Client", "Undelete", "`containerName` must be a lower-cased string.") - } - if blobName == "" { - return result, validation.NewError("blobs.Client", "Undelete", "`blobName` cannot be an empty string.") - } - - req, err := client.UndeletePreparer(ctx, accountName, containerName, blobName) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Undelete", nil, "Failure preparing request") - return - } - - resp, err := client.UndeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "blobs.Client", "Undelete", resp, "Failure sending request") - return - } - - result, err = client.UndeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "blobs.Client", "Undelete", resp, "Failure responding to request") - return - } - - return -} - -// UndeletePreparer prepares the Undelete request. -func (client Client) UndeletePreparer(ctx context.Context, accountName, containerName, blobName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - "blobName": autorest.Encode("path", blobName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "undelete"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}/{blobName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// UndeleteSender sends the Undelete request. The method will close the -// http.Response Body if it receives an error. -func (client Client) UndeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// UndeleteResponder handles the response to the Undelete request. The method always -// closes the http.Response Body. -func (client Client) UndeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go deleted file mode 100644 index b6d69e2233b5..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/blobs/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package blobs - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md deleted file mode 100644 index 9d375483ee8e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/README.md +++ /dev/null @@ -1,45 +0,0 @@ -## Blob Storage Container SDK for API version 2020-08-04 - -This package allows you to interact with the Containers Blob Storage API - -### Supported Authorizers - -* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) -* SharedKeyLite (Blob, File & Queue) - -Note: when using the `ListBlobs` operation, only `SharedKeyLite` authentication is supported. - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - containerName := "mycontainer" - - storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) - containersClient := containers.New() - containersClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - createInput := containers.CreateInput{ - AccessLevel: containers.Private, - } - if _, err := containersClient.Create(ctx, accountName, containerName, createInput); err != nil { - return fmt.Errorf("Error creating Container: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go deleted file mode 100644 index 622f2b00eed7..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/api.go +++ /dev/null @@ -1,25 +0,0 @@ -package containers - -import ( - "context" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageContainer interface { - Create(ctx context.Context, accountName, containerName string, input CreateInput) (result CreateResponse, err error) - Delete(ctx context.Context, accountName, containerName string) (result autorest.Response, err error) - GetProperties(ctx context.Context, accountName, containerName string) (ContainerProperties, error) - GetPropertiesWithLeaseID(ctx context.Context, accountName, containerName, leaseID string) (result ContainerProperties, err error) - AcquireLease(ctx context.Context, accountName, containerName string, input AcquireLeaseInput) (result AcquireLeaseResponse, err error) - BreakLease(ctx context.Context, accountName, containerName string, input BreakLeaseInput) (result BreakLeaseResponse, err error) - ChangeLease(ctx context.Context, accountName, containerName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) - ReleaseLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) - RenewLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) - ListBlobs(ctx context.Context, accountName, containerName string, input ListBlobsInput) (result ListBlobsResult, err error) - GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, containerName string) string - SetAccessControl(ctx context.Context, accountName, containerName string, level AccessLevel) (autorest.Response, error) - SetAccessControlWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, level AccessLevel) (result autorest.Response, err error) - SetMetaData(ctx context.Context, accountName, containerName string, metaData map[string]string) (autorest.Response, error) - SetMetaDataWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, metaData map[string]string) (result autorest.Response, err error) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go deleted file mode 100644 index 7bf494734484..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/client.go +++ /dev/null @@ -1,34 +0,0 @@ -package containers - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Blob Storage Containers. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithBaseURI creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} - -func (client Client) setAccessLevelIntoHeaders(headers map[string]interface{}, level AccessLevel) map[string]interface{} { - // If this header is not included in the request, container data is private to the account owner. - if level != Private { - headers["x-ms-blob-public-access"] = string(level) - } - - return headers -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go deleted file mode 100644 index 84c2887d7d1a..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/create.go +++ /dev/null @@ -1,123 +0,0 @@ -package containers - -import ( - "context" - "fmt" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type CreateInput struct { - // Specifies whether data in the container may be accessed publicly and the level of access - AccessLevel AccessLevel - - // A name-value pair to associate with the container as metadata. - MetaData map[string]string -} - -type CreateResponse struct { - autorest.Response - Error *ErrorResponse `xml:"Error"` -} - -// Create creates a new container under the specified account. -// If the container with the same name already exists, the operation fails. -func (client Client) Create(ctx context.Context, accountName, containerName string, input CreateInput) (result CreateResponse, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "Create", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "Create", "`containerName` cannot be an empty string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("containers.Client", "Create", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.CreatePreparer(ctx, accountName, containerName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "Create", resp, "Failure responding to request") - return - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName string, containerName string, input CreateInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = client.setAccessLevelIntoHeaders(headers, input.AccessLevel) - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result CreateResponse, err error) { - successfulStatusCodes := []int{ - http.StatusCreated, - } - if autorest.ResponseHasStatusCode(resp, successfulStatusCodes...) { - // when successful there's no response - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(successfulStatusCodes...), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - } else { - // however when there's an error the error's in the response - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(successfulStatusCodes...), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - } - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go deleted file mode 100644 index 30958295388e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/delete.go +++ /dev/null @@ -1,85 +0,0 @@ -package containers - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete marks the specified container for deletion. -// The container and any blobs contained within it are later deleted during garbage collection. -func (client Client) Delete(ctx context.Context, accountName, containerName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "Delete", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "Delete", "`containerName` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, containerName) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName string, containerName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go deleted file mode 100644 index 1e308da67c55..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/get_properties.go +++ /dev/null @@ -1,124 +0,0 @@ -package containers - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -// GetProperties returns the properties for this Container without a Lease -func (client Client) GetProperties(ctx context.Context, accountName, containerName string) (ContainerProperties, error) { - // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. - // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. - return client.GetPropertiesWithLeaseID(ctx, accountName, containerName, "") -} - -// GetPropertiesWithLeaseID returns the properties for this Container using the specified LeaseID -func (client Client) GetPropertiesWithLeaseID(ctx context.Context, accountName, containerName, leaseID string) (result ContainerProperties, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "GetPropertiesWithLeaseID", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "GetPropertiesWithLeaseID", "`containerName` cannot be an empty string.") - } - - req, err := client.GetPropertiesWithLeaseIDPreparer(ctx, accountName, containerName, leaseID) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "GetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetPropertiesWithLeaseIDSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "GetProperties", resp, "Failure sending request") - return - } - - result, err = client.GetPropertiesWithLeaseIDResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "GetProperties", resp, "Failure responding to request") - return - } - - return -} - -// GetPropertiesWithLeaseIDPreparer prepares the GetPropertiesWithLeaseID request. -func (client Client) GetPropertiesWithLeaseIDPreparer(ctx context.Context, accountName, containerName, leaseID string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. - // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. - if leaseID != "" { - headers["x-ms-lease-id"] = leaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetPropertiesWithLeaseIDSender sends the GetPropertiesWithLeaseID request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetPropertiesWithLeaseIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetPropertiesWithLeaseIDResponder handles the response to the GetPropertiesWithLeaseID request. The method always -// closes the http.Response Body. -func (client Client) GetPropertiesWithLeaseIDResponder(resp *http.Response) (result ContainerProperties, err error) { - if resp != nil { - result.LeaseStatus = LeaseStatus(resp.Header.Get("x-ms-lease-status")) - result.LeaseState = LeaseState(resp.Header.Get("x-ms-lease-state")) - if result.LeaseStatus == Locked { - duration := LeaseDuration(resp.Header.Get("x-ms-lease-duration")) - result.LeaseDuration = &duration - } - - // If this header is not returned in the response, the container is private to the account owner. - accessLevel := resp.Header.Get("x-ms-blob-public-access") - if accessLevel != "" { - result.AccessLevel = AccessLevel(accessLevel) - } else { - result.AccessLevel = Private - } - - // we can't necessarily use strconv.ParseBool here since this could be nil (only in some API versions) - result.HasImmutabilityPolicy = strings.EqualFold(resp.Header.Get("x-ms-has-immutability-policy"), "true") - result.HasLegalHold = strings.EqualFold(resp.Header.Get("x-ms-has-legal-hold"), "true") - - result.MetaData = metadata.ParseFromHeaders(resp.Header) - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go deleted file mode 100644 index 061c863c43f9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_acquire.go +++ /dev/null @@ -1,115 +0,0 @@ -package containers - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type AcquireLeaseInput struct { - // Specifies the duration of the lease, in seconds, or negative one (-1) for a lease that never expires. - // A non-infinite lease can be between 15 and 60 seconds - LeaseDuration int - - ProposedLeaseID string -} - -type AcquireLeaseResponse struct { - autorest.Response - - LeaseID string -} - -// AcquireLease establishes and manages a lock on a container for delete operations. -func (client Client) AcquireLease(ctx context.Context, accountName, containerName string, input AcquireLeaseInput) (result AcquireLeaseResponse, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "AcquireLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "AcquireLease", "`containerName` cannot be an empty string.") - } - // An infinite lease duration is -1 seconds. A non-infinite lease can be between 15 and 60 seconds - if input.LeaseDuration != -1 && (input.LeaseDuration <= 15 || input.LeaseDuration >= 60) { - return result, validation.NewError("containers.Client", "AcquireLease", "`input.LeaseDuration` must be -1 (infinite), or between 15 and 60 seconds.") - } - - req, err := client.AcquireLeasePreparer(ctx, accountName, containerName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "AcquireLease", nil, "Failure preparing request") - return - } - - resp, err := client.AcquireLeaseSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "AcquireLease", resp, "Failure sending request") - return - } - - result, err = client.AcquireLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "AcquireLease", resp, "Failure responding to request") - return - } - - return -} - -// AcquireLeasePreparer prepares the AcquireLease request. -func (client Client) AcquireLeasePreparer(ctx context.Context, accountName string, containerName string, input AcquireLeaseInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - "comp": autorest.Encode("path", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "acquire", - "x-ms-lease-duration": input.LeaseDuration, - } - - if input.ProposedLeaseID != "" { - headers["x-ms-proposed-lease-id"] = input.ProposedLeaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// AcquireLeaseSender sends the AcquireLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) AcquireLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// AcquireLeaseResponder handles the response to the AcquireLease request. The method always -// closes the http.Response Body. -func (client Client) AcquireLeaseResponder(resp *http.Response) (result AcquireLeaseResponse, err error) { - if resp != nil { - result.LeaseID = resp.Header.Get("x-ms-lease-id") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go deleted file mode 100644 index 08acfb7a3116..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_break.go +++ /dev/null @@ -1,129 +0,0 @@ -package containers - -import ( - "context" - "net/http" - "strconv" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type BreakLeaseInput struct { - // For a break operation, proposed duration the lease should continue - // before it is broken, in seconds, between 0 and 60. - // This break period is only used if it is shorter than the time remaining on the lease. - // If longer, the time remaining on the lease is used. - // A new lease will not be available before the break period has expired, - // but the lease may be held for longer than the break period. - // If this header does not appear with a break operation, a fixed-duration lease breaks - // after the remaining lease period elapses, and an infinite lease breaks immediately. - BreakPeriod *int - - LeaseID string -} - -type BreakLeaseResponse struct { - autorest.Response - - // Approximate time remaining in the lease period, in seconds. - // If the break is immediate, 0 is returned. - LeaseTime int -} - -// BreakLease breaks a lock based on it's Lease ID -func (client Client) BreakLease(ctx context.Context, accountName, containerName string, input BreakLeaseInput) (result BreakLeaseResponse, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "BreakLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "BreakLease", "`containerName` cannot be an empty string.") - } - if input.LeaseID == "" { - return result, validation.NewError("containers.Client", "BreakLease", "`input.LeaseID` cannot be an empty string.") - } - - req, err := client.BreakLeasePreparer(ctx, accountName, containerName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "BreakLease", nil, "Failure preparing request") - return - } - - resp, err := client.BreakLeaseSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "BreakLease", resp, "Failure sending request") - return - } - - result, err = client.BreakLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "BreakLease", resp, "Failure responding to request") - return - } - - return -} - -// BreakLeasePreparer prepares the BreakLease request. -func (client Client) BreakLeasePreparer(ctx context.Context, accountName string, containerName string, input BreakLeaseInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - "comp": autorest.Encode("path", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "break", - "x-ms-lease-id": input.LeaseID, - } - - if input.BreakPeriod != nil { - headers["x-ms-lease-break-period"] = *input.BreakPeriod - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// BreakLeaseSender sends the BreakLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) BreakLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// BreakLeaseResponder handles the response to the BreakLease request. The method always -// closes the http.Response Body. -func (client Client) BreakLeaseResponder(resp *http.Response) (result BreakLeaseResponse, err error) { - if resp != nil { - leaseRaw := resp.Header.Get("x-ms-lease-time") - if leaseRaw != "" { - i, err := strconv.Atoi(leaseRaw) - if err == nil { - result.LeaseTime = i - } - } - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go deleted file mode 100644 index dfbcb132dae3..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_change.go +++ /dev/null @@ -1,111 +0,0 @@ -package containers - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type ChangeLeaseInput struct { - ExistingLeaseID string - ProposedLeaseID string -} - -type ChangeLeaseResponse struct { - autorest.Response - - LeaseID string -} - -// ChangeLease changes the lock from one Lease ID to another Lease ID -func (client Client) ChangeLease(ctx context.Context, accountName, containerName string, input ChangeLeaseInput) (result ChangeLeaseResponse, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "ChangeLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "ChangeLease", "`containerName` cannot be an empty string.") - } - if input.ExistingLeaseID == "" { - return result, validation.NewError("containers.Client", "ChangeLease", "`input.ExistingLeaseID` cannot be an empty string.") - } - if input.ProposedLeaseID == "" { - return result, validation.NewError("containers.Client", "ChangeLease", "`input.ProposedLeaseID` cannot be an empty string.") - } - - req, err := client.ChangeLeasePreparer(ctx, accountName, containerName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "ChangeLease", nil, "Failure preparing request") - return - } - - resp, err := client.ChangeLeaseSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "ChangeLease", resp, "Failure sending request") - return - } - - result, err = client.ChangeLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "ChangeLease", resp, "Failure responding to request") - return - } - - return -} - -// ChangeLeasePreparer prepares the ChangeLease request. -func (client Client) ChangeLeasePreparer(ctx context.Context, accountName string, containerName string, input ChangeLeaseInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - "comp": autorest.Encode("path", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "change", - "x-ms-lease-id": input.ExistingLeaseID, - "x-ms-proposed-lease-id": input.ProposedLeaseID, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ChangeLeaseSender sends the ChangeLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ChangeLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ChangeLeaseResponder handles the response to the ChangeLease request. The method always -// closes the http.Response Body. -func (client Client) ChangeLeaseResponder(resp *http.Response) (result ChangeLeaseResponse, err error) { - if resp != nil { - result.LeaseID = resp.Header.Get("x-ms-lease-id") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go deleted file mode 100644 index fafcf98f1e67..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_release.go +++ /dev/null @@ -1,92 +0,0 @@ -package containers - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// ReleaseLease releases the lock based on the Lease ID -func (client Client) ReleaseLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "ReleaseLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "ReleaseLease", "`containerName` cannot be an empty string.") - } - if leaseID == "" { - return result, validation.NewError("containers.Client", "ReleaseLease", "`leaseID` cannot be an empty string.") - } - - req, err := client.ReleaseLeasePreparer(ctx, accountName, containerName, leaseID) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "ReleaseLease", nil, "Failure preparing request") - return - } - - resp, err := client.ReleaseLeaseSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "ReleaseLease", resp, "Failure sending request") - return - } - - result, err = client.ReleaseLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "ReleaseLease", resp, "Failure responding to request") - return - } - - return -} - -// ReleaseLeasePreparer prepares the ReleaseLease request. -func (client Client) ReleaseLeasePreparer(ctx context.Context, accountName string, containerName string, leaseID string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - "comp": autorest.Encode("path", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "release", - "x-ms-lease-id": leaseID, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ReleaseLeaseSender sends the ReleaseLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ReleaseLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ReleaseLeaseResponder handles the response to the ReleaseLease request. The method always -// closes the http.Response Body. -func (client Client) ReleaseLeaseResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go deleted file mode 100644 index cab50bff9d21..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/lease_renew.go +++ /dev/null @@ -1,92 +0,0 @@ -package containers - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// RenewLease renews the lock based on the Lease ID -func (client Client) RenewLease(ctx context.Context, accountName, containerName, leaseID string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "RenewLease", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "RenewLease", "`containerName` cannot be an empty string.") - } - if leaseID == "" { - return result, validation.NewError("containers.Client", "RenewLease", "`leaseID` cannot be an empty string.") - } - - req, err := client.RenewLeasePreparer(ctx, accountName, containerName, leaseID) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "RenewLease", nil, "Failure preparing request") - return - } - - resp, err := client.RenewLeaseSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "RenewLease", resp, "Failure sending request") - return - } - - result, err = client.RenewLeaseResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "RenewLease", resp, "Failure responding to request") - return - } - - return -} - -// RenewLeasePreparer prepares the RenewLease request. -func (client Client) RenewLeasePreparer(ctx context.Context, accountName string, containerName string, leaseID string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "container"), - "comp": autorest.Encode("path", "lease"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-lease-action": "renew", - "x-ms-lease-id": leaseID, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// RenewLeaseSender sends the RenewLease request. The method will close the -// http.Response Body if it receives an error. -func (client Client) RenewLeaseSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// RenewLeaseResponder handles the response to the RenewLease request. The method always -// closes the http.Response Body. -func (client Client) RenewLeaseResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go deleted file mode 100644 index 82797d091d36..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/list_blobs.go +++ /dev/null @@ -1,179 +0,0 @@ -package containers - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type ListBlobsInput struct { - Delimiter *string - Include *[]Dataset - Marker *string - MaxResults *int - Prefix *string -} - -type ListBlobsResult struct { - autorest.Response - - Delimiter string `xml:"Delimiter"` - Marker string `xml:"Marker"` - MaxResults int `xml:"MaxResults"` - NextMarker *string `xml:"NextMarker,omitempty"` - Prefix string `xml:"Prefix"` - Blobs Blobs `xml:"Blobs"` -} - -type Blobs struct { - Blobs []BlobDetails `xml:"Blob"` - BlobPrefix *BlobPrefix `xml:"BlobPrefix"` -} - -type BlobDetails struct { - Name string `xml:"Name"` - Deleted bool `xml:"Deleted,omitempty"` - MetaData map[string]interface{} `map:"Metadata,omitempty"` - Properties *BlobProperties `xml:"Properties,omitempty"` - Snapshot *string `xml:"Snapshot,omitempty"` -} - -type BlobProperties struct { - AccessTier *string `xml:"AccessTier,omitempty"` - AccessTierInferred *bool `xml:"AccessTierInferred,omitempty"` - AccessTierChangeTime *string `xml:"AccessTierChangeTime,omitempty"` - BlobType *string `xml:"BlobType,omitempty"` - BlobSequenceNumber *string `xml:"x-ms-blob-sequence-number,omitempty"` - CacheControl *string `xml:"Cache-Control,omitempty"` - ContentEncoding *string `xml:"ContentEncoding,omitempty"` - ContentLanguage *string `xml:"Content-Language,omitempty"` - ContentLength *int64 `xml:"Content-Length,omitempty"` - ContentMD5 *string `xml:"Content-MD5,omitempty"` - ContentType *string `xml:"Content-Type,omitempty"` - CopyCompletionTime *string `xml:"CopyCompletionTime,omitempty"` - CopyId *string `xml:"CopyId,omitempty"` - CopyStatus *string `xml:"CopyStatus,omitempty"` - CopySource *string `xml:"CopySource,omitempty"` - CopyProgress *string `xml:"CopyProgress,omitempty"` - CopyStatusDescription *string `xml:"CopyStatusDescription,omitempty"` - CreationTime *string `xml:"CreationTime,omitempty"` - ETag *string `xml:"Etag,omitempty"` - DeletedTime *string `xml:"DeletedTime,omitempty"` - IncrementalCopy *bool `xml:"IncrementalCopy,omitempty"` - LastModified *string `xml:"Last-Modified,omitempty"` - LeaseDuration *string `xml:"LeaseDuration,omitempty"` - LeaseState *string `xml:"LeaseState,omitempty"` - LeaseStatus *string `xml:"LeaseStatus,omitempty"` - RemainingRetentionDays *string `xml:"RemainingRetentionDays,omitempty"` - ServerEncrypted *bool `xml:"ServerEncrypted,omitempty"` -} - -type BlobPrefix struct { - Name string `xml:"Name"` -} - -// ListBlobs lists the blobs matching the specified query within the specified Container -func (client Client) ListBlobs(ctx context.Context, accountName, containerName string, input ListBlobsInput) (result ListBlobsResult, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "ListBlobs", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "ListBlobs", "`containerName` cannot be an empty string.") - } - if input.MaxResults != nil && (*input.MaxResults <= 0 || *input.MaxResults > 5000) { - return result, validation.NewError("containers.Client", "ListBlobs", "`input.MaxResults` can either be nil or between 0 and 5000.") - } - - req, err := client.ListBlobsPreparer(ctx, accountName, containerName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "ListBlobs", nil, "Failure preparing request") - return - } - - resp, err := client.ListBlobsSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "ListBlobs", resp, "Failure sending request") - return - } - - result, err = client.ListBlobsResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "ListBlobs", resp, "Failure responding to request") - return - } - - return -} - -// ListBlobsPreparer prepares the ListBlobs request. -func (client Client) ListBlobsPreparer(ctx context.Context, accountName, containerName string, input ListBlobsInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "list"), - "restype": autorest.Encode("query", "container"), - } - - if input.Delimiter != nil { - queryParameters["delimiter"] = autorest.Encode("query", *input.Delimiter) - } - if input.Include != nil { - vals := make([]string, 0) - for _, v := range *input.Include { - vals = append(vals, string(v)) - } - include := strings.Join(vals, ",") - queryParameters["include"] = autorest.Encode("query", include) - } - if input.Marker != nil { - queryParameters["marker"] = autorest.Encode("query", *input.Marker) - } - if input.MaxResults != nil { - queryParameters["maxresults"] = autorest.Encode("query", *input.MaxResults) - } - if input.Prefix != nil { - queryParameters["prefix"] = autorest.Encode("query", *input.Prefix) - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ListBlobsSender sends the ListBlobs request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ListBlobsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ListBlobsResponder handles the response to the ListBlobs request. The method always -// closes the http.Response Body. -func (client Client) ListBlobsResponder(resp *http.Response) (result ListBlobsResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go deleted file mode 100644 index adba36818aa1..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/models.go +++ /dev/null @@ -1,75 +0,0 @@ -package containers - -import "github.com/Azure/go-autorest/autorest" - -type AccessLevel string - -var ( - // Blob specifies public read access for blobs. - // Blob data within this container can be read via anonymous request, - // but container data is not available. - // Clients cannot enumerate blobs within the container via anonymous request. - Blob AccessLevel = "blob" - - // Container specifies full public read access for container and blob data. - // Clients can enumerate blobs within the container via anonymous request, - // but cannot enumerate containers within the storage account. - Container AccessLevel = "container" - - // Private specifies that container data is private to the account owner - Private AccessLevel = "" -) - -type ContainerProperties struct { - autorest.Response - - AccessLevel AccessLevel - LeaseStatus LeaseStatus - LeaseState LeaseState - LeaseDuration *LeaseDuration - MetaData map[string]string - HasImmutabilityPolicy bool - HasLegalHold bool -} - -type Dataset string - -var ( - Copy Dataset = "copy" - Deleted Dataset = "deleted" - MetaData Dataset = "metadata" - Snapshots Dataset = "snapshots" - UncommittedBlobs Dataset = "uncommittedblobs" -) - -type ErrorResponse struct { - Code *string `xml:"Code"` - Message *string `xml:"Message"` -} - -type LeaseDuration string - -var ( - // If this lease is for a Fixed Duration - Fixed LeaseDuration = "fixed" - - // If this lease is for an Indefinite Duration - Infinite LeaseDuration = "infinite" -) - -type LeaseState string - -var ( - Available LeaseState = "available" - Breaking LeaseState = "breaking" - Broken LeaseState = "broken" - Expired LeaseState = "expired" - Leased LeaseState = "leased" -) - -type LeaseStatus string - -var ( - Locked LeaseStatus = "locked" - Unlocked LeaseStatus = "unlocked" -) diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go deleted file mode 100644 index d35674a7868d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/resource_id.go +++ /dev/null @@ -1,53 +0,0 @@ -package containers - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Container -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, containerName string) string { - domain := endpoints.GetBlobEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s", domain, containerName) -} - -// GetResourceManagerResourceID returns the Resource Manager specific -// ResourceID for a specific Storage Container -func (client Client) GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, containerName string) string { - fmtStr := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Storage/storageAccounts/%s/blobServices/default/containers/%s" - return fmt.Sprintf(fmtStr, subscriptionID, resourceGroup, accountName, containerName) -} - -type ResourceID struct { - AccountName string - ContainerName string -} - -// ParseResourceID parses the Resource ID and returns an object which can be used -// to interact with the Container Resource -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.blob.core.windows.net/Bar - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - containerName := strings.TrimPrefix(uri.Path, "/") - return &ResourceID{ - AccountName: *accountName, - ContainerName: containerName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go deleted file mode 100644 index fcf4e1056fa4..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_acl.go +++ /dev/null @@ -1,100 +0,0 @@ -package containers - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// SetAccessControl sets the Access Control for a Container without a Lease ID -func (client Client) SetAccessControl(ctx context.Context, accountName, containerName string, level AccessLevel) (autorest.Response, error) { - return client.SetAccessControlWithLeaseID(ctx, accountName, containerName, "", level) -} - -// SetAccessControlWithLeaseID sets the Access Control for a Container using the specified Lease ID -func (client Client) SetAccessControlWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, level AccessLevel) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "SetAccessControl", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "SetAccessControl", "`containerName` cannot be an empty string.") - } - - req, err := client.SetAccessControlWithLeaseIDPreparer(ctx, accountName, containerName, leaseID, level) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "SetAccessControl", nil, "Failure preparing request") - return - } - - resp, err := client.SetAccessControlWithLeaseIDSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "SetAccessControl", resp, "Failure sending request") - return - } - - result, err = client.SetAccessControlWithLeaseIDResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "SetAccessControl", resp, "Failure responding to request") - return - } - - return -} - -// SetAccessControlWithLeaseIDPreparer prepares the SetAccessControlWithLeaseID request. -func (client Client) SetAccessControlWithLeaseIDPreparer(ctx context.Context, accountName, containerName, leaseID string, level AccessLevel) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "acl"), - "restype": autorest.Encode("path", "container"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = client.setAccessLevelIntoHeaders(headers, level) - - // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. - // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. - if leaseID != "" { - headers["x-ms-lease-id"] = leaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetAccessControlWithLeaseIDSender sends the SetAccessControlWithLeaseID request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetAccessControlWithLeaseIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetAccessControlWithLeaseIDResponder handles the response to the SetAccessControlWithLeaseID request. The method always -// closes the http.Response Body. -func (client Client) SetAccessControlWithLeaseIDResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go deleted file mode 100644 index fb9e07fdefa9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/set_metadata.go +++ /dev/null @@ -1,105 +0,0 @@ -package containers - -import ( - "context" - "fmt" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -// SetMetaData sets the specified MetaData on the Container without a Lease ID -func (client Client) SetMetaData(ctx context.Context, accountName, containerName string, metaData map[string]string) (autorest.Response, error) { - return client.SetMetaDataWithLeaseID(ctx, accountName, containerName, "", metaData) -} - -// SetMetaDataWithLeaseID sets the specified MetaData on the Container using the specified Lease ID -func (client Client) SetMetaDataWithLeaseID(ctx context.Context, accountName, containerName, leaseID string, metaData map[string]string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("containers.Client", "SetMetaData", "`accountName` cannot be an empty string.") - } - if containerName == "" { - return result, validation.NewError("containers.Client", "SetMetaData", "`containerName` cannot be an empty string.") - } - if err := metadata.Validate(metaData); err != nil { - return result, validation.NewError("containers.Client", "SetMetaData", fmt.Sprintf("`metaData` is not valid: %s.", err)) - } - - req, err := client.SetMetaDataWithLeaseIDPreparer(ctx, accountName, containerName, leaseID, metaData) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "SetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.SetMetaDataWithLeaseIDSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "containers.Client", "SetMetaData", resp, "Failure sending request") - return - } - - result, err = client.SetMetaDataWithLeaseIDResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "containers.Client", "SetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// SetMetaDataWithLeaseIDPreparer prepares the SetMetaDataWithLeaseID request. -func (client Client) SetMetaDataWithLeaseIDPreparer(ctx context.Context, accountName, containerName, leaseID string, metaData map[string]string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "containerName": autorest.Encode("path", containerName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "metadata"), - "restype": autorest.Encode("path", "container"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = metadata.SetIntoHeaders(headers, metaData) - - // If specified, Get Container Properties only succeeds if the container’s lease is active and matches this ID. - // If there is no active lease or the ID does not match, 412 (Precondition Failed) is returned. - if leaseID != "" { - headers["x-ms-lease-id"] = leaseID - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetBlobEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{containerName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetMetaDataWithLeaseIDSender sends the SetMetaDataWithLeaseID request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetMetaDataWithLeaseIDSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetMetaDataWithLeaseIDResponder handles the response to the SetMetaDataWithLeaseID request. The method always -// closes the http.Response Body. -func (client Client) SetMetaDataWithLeaseIDResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go deleted file mode 100644 index d3138cb35875..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/blob/containers/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package containers - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md deleted file mode 100644 index be6fb76139d5..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/README.md +++ /dev/null @@ -1,84 +0,0 @@ -## Data Lake Storage Gen2 File Systems SDK for API version 2020-08-04 - -This package allows you to interact with the Data Lake Storage Gen2 File Systems API - -### Supported Authorizers - -* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "os" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/adal" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/hashicorp/go-azure-helpers/authentication" - "github.com/hashicorp/go-azure-helpers/sender" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems" -) - -func Example() error { - accountName := "storageaccount1" - fileSystemName := "filesystem1" - - builder := &authentication.Builder{ - SubscriptionID: os.Getenv("ARM_SUBSCRIPTION_ID"), - ClientID: os.Getenv("ARM_CLIENT_ID"), - ClientSecret: os.Getenv("ARM_CLIENT_SECRET"), - TenantID: os.Getenv("ARM_TENANT_ID"), - Environment: os.Getenv("ARM_ENVIRONMENT"), - - // Feature Toggles - SupportsClientSecretAuth: true, - } - - c, err := builder.Build() - if err != nil { - return fmt.Errorf("Error building AzureRM Client: %s", err) - } - - env, err := authentication.DetermineEnvironment(c.Environment) - if err != nil { - return err - } - - oauthConfig, err := adal.NewOAuthConfig(env.ActiveDirectoryEndpoint, c.TenantID) - if err != nil { - return err - } - - // OAuthConfigForTenant returns a pointer, which can be nil. - if oauthConfig == nil { - return fmt.Errorf("Unable to configure OAuthConfig for tenant %s", c.TenantID) - } - - sender := sender.BuildSender("AzureRM") - ctx := context.Background() - - storageAuth, err := config.GetAuthorizationToken(sender, oauthConfig, "https://storage.azure.com/") - if err != nil { - return fmt.Errorf("Error retrieving Authorization Token") - } - - - fileSystemsClient := filesystems.NewWithEnvironment(env) - fileSystemsClient.Client.Authorizer = storageAuth - - input := filesystems.CreateInput{ - Properties: map[string]string{}, - } - if _, err = fileSystemsClient.Create(ctx, accountName, fileSystemName, input); err != nil { - return fmt.Errorf("Error creating: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go deleted file mode 100644 index 91d3fe1cf45e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package filesystems - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Data Lake Storage FileSystem -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Data Lake Storage FileSystem client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Data Lake Storage FileSystem client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go deleted file mode 100644 index 4217cb80af0e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/create.go +++ /dev/null @@ -1,94 +0,0 @@ -package filesystems - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type CreateInput struct { - // A map of base64-encoded strings to store as user-defined properties with the File System - // Note that items may only contain ASCII characters in the ISO-8859-1 character set. - // This automatically gets converted to a comma-separated list of name and - // value pairs before sending to the API - Properties map[string]string -} - -// Create creates a Data Lake Store Gen2 FileSystem within a Storage Account -func (client Client) Create(ctx context.Context, accountName string, fileSystemName string, input CreateInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "Create", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "Create", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.CreatePreparer(ctx, accountName, fileSystemName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure responding to request") - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName string, fileSystemName string, input CreateInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - } - - queryParameters := map[string]interface{}{ - "resource": autorest.Encode("query", "filesystem"), - } - - headers := map[string]interface{}{ - "x-ms-properties": buildProperties(input.Properties), - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go deleted file mode 100644 index fabc589da940..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/delete.go +++ /dev/null @@ -1,85 +0,0 @@ -package filesystems - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete deletes a Data Lake Store Gen2 FileSystem within a Storage Account -func (client Client) Delete(ctx context.Context, accountName string, fileSystemName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "Delete", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "Delete", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, fileSystemName) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure responding to request") - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName string, fileSystemName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - } - - queryParameters := map[string]interface{}{ - "resource": autorest.Encode("query", "filesystem"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go deleted file mode 100644 index 605ed425929d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/helpers.go +++ /dev/null @@ -1,40 +0,0 @@ -package filesystems - -import ( - "fmt" - "strings" -) - -func buildProperties(input map[string]string) string { - // properties has to be a comma-separated key-value pair - properties := make([]string, 0) - - for k, v := range input { - properties = append(properties, fmt.Sprintf("%s=%s", k, v)) - } - - return strings.Join(properties, ",") -} - -func parseProperties(input string) (*map[string]string, error) { - properties := make(map[string]string) - if input == "" { - return &properties, nil - } - - // properties is a comma-separated list of key-value pairs - splitProperties := strings.Split(input, ",") - for _, propertyRaw := range splitProperties { - // because these are base64-encoded they're likely to end in at least one = - // as such we can't string split on that -_- - position := strings.Index(propertyRaw, "=") - if position < 0 { - return nil, fmt.Errorf("Expected there to be an equals in the key value pair: %q", propertyRaw) - } - - key := propertyRaw[0:position] - value := propertyRaw[position+1:] - properties[key] = value - } - return &properties, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go deleted file mode 100644 index 0b96c95edd52..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_get.go +++ /dev/null @@ -1,112 +0,0 @@ -package filesystems - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetPropertiesResponse struct { - autorest.Response - - // A map of base64-encoded strings to store as user-defined properties with the File System - // Note that items may only contain ASCII characters in the ISO-8859-1 character set. - // This automatically gets converted to a comma-separated list of name and - // value pairs before sending to the API - Properties map[string]string - - // Is Hierarchical Namespace Enabled? - NamespaceEnabled bool -} - -// GetProperties gets the properties for a Data Lake Store Gen2 FileSystem within a Storage Account -func (client Client) GetProperties(ctx context.Context, accountName string, fileSystemName string) (result GetPropertiesResponse, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "GetProperties", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "GetProperties", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.GetPropertiesPreparer(ctx, accountName, fileSystemName) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetPropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure sending request") - return - } - - result, err = client.GetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure responding to request") - } - - return -} - -// GetPropertiesPreparer prepares the GetProperties request. -func (client Client) GetPropertiesPreparer(ctx context.Context, accountName string, fileSystemName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - } - - queryParameters := map[string]interface{}{ - "resource": autorest.Encode("query", "filesystem"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsHead(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - - 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetPropertiesResponder handles the response to the GetProperties request. The method always -// closes the http.Response Body. -func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResponse, err error) { - if resp != nil && resp.Header != nil { - - propertiesRaw := resp.Header.Get("x-ms-properties") - var properties *map[string]string - properties, err = parseProperties(propertiesRaw) - if err != nil { - return - } - - result.Properties = *properties - result.NamespaceEnabled = strings.EqualFold(resp.Header.Get("x-ms-namespace-enabled"), "tru") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go deleted file mode 100644 index dde02a4455b9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/properties_set.go +++ /dev/null @@ -1,109 +0,0 @@ -package filesystems - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type SetPropertiesInput struct { - // A map of base64-encoded strings to store as user-defined properties with the File System - // Note that items may only contain ASCII characters in the ISO-8859-1 character set. - // This automatically gets converted to a comma-separated list of name and - // value pairs before sending to the API - Properties map[string]string - - // Optional - A date and time value. - // Specify this header to perform the operation only if the resource has been modified since the specified date and time. - IfModifiedSince *string - - // Optional - A date and time value. - // Specify this header to perform the operation only if the resource has not been modified since the specified date and time. - IfUnmodifiedSince *string -} - -// SetProperties sets the Properties for a Data Lake Store Gen2 FileSystem within a Storage Account -func (client Client) SetProperties(ctx context.Context, accountName string, fileSystemName string, input SetPropertiesInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "SetProperties", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "SetProperties", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.SetPropertiesPreparer(ctx, accountName, fileSystemName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.SetPropertiesSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetProperties", resp, "Failure sending request") - return - } - - result, err = client.SetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetProperties", resp, "Failure responding to request") - } - - return -} - -// SetPropertiesPreparer prepares the SetProperties request. -func (client Client) SetPropertiesPreparer(ctx context.Context, accountName string, fileSystemName string, input SetPropertiesInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - } - - queryParameters := map[string]interface{}{ - "resource": autorest.Encode("query", "filesystem"), - } - - headers := map[string]interface{}{ - "x-ms-properties": buildProperties(input.Properties), - "x-ms-version": APIVersion, - } - - if input.IfModifiedSince != nil { - headers["If-Modified-Since"] = *input.IfModifiedSince - } - if input.IfUnmodifiedSince != nil { - headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince - } - - preparer := autorest.CreatePreparer( - autorest.AsPatch(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetPropertiesSender sends the SetProperties request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetPropertiesResponder handles the response to the SetProperties request. The method always -// closes the http.Response Body. -func (client Client) SetPropertiesResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go deleted file mode 100644 index 34797b20b7a9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/resource_id.go +++ /dev/null @@ -1,46 +0,0 @@ -package filesystems - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Data Lake Storage FileSystem -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, shareName string) string { - domain := endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s", domain, shareName) -} - -type ResourceID struct { - AccountName string - DirectoryName string -} - -// ParseResourceID parses the specified Resource ID and returns an object -// which can be used to interact with the Data Lake Storage FileSystem API's -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.dfs.core.windows.net/Bar - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - directoryName := strings.TrimPrefix(uri.Path, "/") - return &ResourceID{ - AccountName: *accountName, - DirectoryName: directoryName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go deleted file mode 100644 index 7447ea9ade09..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/filesystems/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package filesystems - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go deleted file mode 100644 index 3fb087bf8c8d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package paths - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Data Lake Storage Path -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Data Lake Storage Path client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Data Lake Storage Path client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go deleted file mode 100644 index 600bd75a9a87..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/create.go +++ /dev/null @@ -1,95 +0,0 @@ -package paths - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type PathResource string - -const PathResourceFile PathResource = "file" -const PathResourceDirectory PathResource = "directory" - -type CreateInput struct { - Resource PathResource -} - -// Create creates a Data Lake Store Gen2 Path within a Storage Account -func (client Client) Create(ctx context.Context, accountName string, fileSystemName string, path string, input CreateInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "Create", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "Create", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.CreatePreparer(ctx, accountName, fileSystemName, path, input) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Create", resp, "Failure responding to request") - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName string, fileSystemName string, path string, input CreateInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - "path": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "resource": autorest.Encode("query", input.Resource), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go deleted file mode 100644 index 078be57915af..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/delete.go +++ /dev/null @@ -1,81 +0,0 @@ -package paths - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete deletes a Data Lake Store Gen2 FileSystem within a Storage Account -func (client Client) Delete(ctx context.Context, accountName string, fileSystemName string, path string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "Delete", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "Delete", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, fileSystemName, path) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "Delete", resp, "Failure responding to request") - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName string, fileSystemName string, path string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - "path": autorest.Encode("path", path), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), - autorest.WithHeaders(headers)) - - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go deleted file mode 100644 index e6ef6f4bfb9f..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/helpers.go +++ /dev/null @@ -1,15 +0,0 @@ -package paths - -import ( - "fmt" -) - -func parsePathResource(input string) (PathResource, error) { - switch input { - case "file": - return PathResourceFile, nil - case "directory": - return PathResourceDirectory, nil - } - return "", fmt.Errorf("Unhandled path resource type %q", input) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go deleted file mode 100644 index 263dc53ed95b..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_get.go +++ /dev/null @@ -1,134 +0,0 @@ -package paths - -import ( - "context" - "net/http" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetPropertiesResponse struct { - autorest.Response - - ETag string - LastModified time.Time - // ResourceType is only returned for GetPropertiesActionGetStatus requests - ResourceType PathResource - Owner string - Group string - // ACL is only returned for GetPropertiesActionGetAccessControl requests - ACL string -} - -type GetPropertiesAction string - -const ( - GetPropertiesActionGetStatus GetPropertiesAction = "getStatus" - GetPropertiesActionGetAccessControl GetPropertiesAction = "getAccessControl" -) - -// GetProperties gets the properties for a Data Lake Store Gen2 Path in a FileSystem within a Storage Account -func (client Client) GetProperties(ctx context.Context, accountName string, fileSystemName string, path string, action GetPropertiesAction) (result GetPropertiesResponse, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "GetProperties", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "GetProperties", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.GetPropertiesPreparer(ctx, accountName, fileSystemName, path, action) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetPropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure sending request") - return - } - - result, err = client.GetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "GetProperties", resp, "Failure responding to request") - } - - return -} - -// GetPropertiesPreparer prepares the GetProperties request. -func (client Client) GetPropertiesPreparer(ctx context.Context, accountName string, fileSystemName string, path string, action GetPropertiesAction) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - "path": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "action": autorest.Encode("query", string(action)), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsHead(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - - 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetPropertiesResponder handles the response to the GetProperties request. The method always -// closes the http.Response Body. -func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResponse, err error) { - result = GetPropertiesResponse{} - if resp != nil && resp.Header != nil { - - resourceTypeRaw := resp.Header.Get("x-ms-resource-type") - var resourceType PathResource - if resourceTypeRaw != "" { - resourceType, err = parsePathResource(resourceTypeRaw) - if err != nil { - return GetPropertiesResponse{}, err - } - result.ResourceType = resourceType - } - result.ETag = resp.Header.Get("ETag") - - if lastModifiedRaw := resp.Header.Get("Last-Modified"); lastModifiedRaw != "" { - lastModified, err := time.Parse(time.RFC1123, lastModifiedRaw) - if err != nil { - return GetPropertiesResponse{}, err - } - result.LastModified = lastModified - } - - result.Owner = resp.Header.Get("x-ms-owner") - result.Group = resp.Header.Get("x-ms-group") - result.ACL = resp.Header.Get("x-ms-acl") - } - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return result, err -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go deleted file mode 100644 index 7c0d677647d0..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/properties_set.go +++ /dev/null @@ -1,116 +0,0 @@ -package paths - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type SetAccessControlInput struct { - Owner *string - Group *string - ACL *string - - // Optional - A date and time value. - // Specify this header to perform the operation only if the resource has been modified since the specified date and time. - IfModifiedSince *string - - // Optional - A date and time value. - // Specify this header to perform the operation only if the resource has not been modified since the specified date and time. - IfUnmodifiedSince *string -} - -// SetProperties sets the access control properties for a Data Lake Store Gen2 Path within a Storage Account File System -func (client Client) SetAccessControl(ctx context.Context, accountName string, fileSystemName string, path string, input SetAccessControlInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("datalakestore.Client", "SetAccessControl", "`accountName` cannot be an empty string.") - } - if fileSystemName == "" { - return result, validation.NewError("datalakestore.Client", "SetAccessControl", "`fileSystemName` cannot be an empty string.") - } - - req, err := client.SetAccessControlPreparer(ctx, accountName, fileSystemName, path, input) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetAccessControl", nil, "Failure preparing request") - return - } - - resp, err := client.SetAccessControlSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetAccessControl", resp, "Failure sending request") - return - } - - result, err = client.SetAccessControlResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "datalakestore.Client", "SetAccessControl", resp, "Failure responding to request") - } - - return -} - -// SetAccessControlPreparer prepares the SetAccessControl request. -func (client Client) SetAccessControlPreparer(ctx context.Context, accountName string, fileSystemName string, path string, input SetAccessControlInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "fileSystemName": autorest.Encode("path", fileSystemName), - "path": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "action": autorest.Encode("query", "setAccessControl"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if input.Owner != nil { - headers["x-ms-owner"] = *input.Owner - } - if input.Group != nil { - headers["x-ms-group"] = *input.Group - } - if input.ACL != nil { - headers["x-ms-acl"] = *input.ACL - } - - if input.IfModifiedSince != nil { - headers["If-Modified-Since"] = *input.IfModifiedSince - } - if input.IfUnmodifiedSince != nil { - headers["If-Unmodified-Since"] = *input.IfUnmodifiedSince - } - - preparer := autorest.CreatePreparer( - autorest.AsPatch(), - autorest.WithBaseURL(endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{fileSystemName}/{path}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetAccessControlSender sends the SetAccessControl request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetAccessControlSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetAccessControlResponder handles the response to the SetAccessControl request. The method always -// closes the http.Response Body. -func (client Client) SetAccessControlResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go deleted file mode 100644 index c32841877067..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/resource_id.go +++ /dev/null @@ -1,57 +0,0 @@ -package paths - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Data Lake Storage FileSystem -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, fileSystemName, path string) string { - domain := endpoints.GetDataLakeStoreEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s/%s", domain, fileSystemName, path) -} - -type ResourceID struct { - AccountName string - FileSystemName string - Path string -} - -// ParseResourceID parses the specified Resource ID and returns an object -// which can be used to interact with the Data Lake Storage FileSystem API's -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.dfs.core.windows.net/Bar - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - fileSystemAndPath := strings.TrimPrefix(uri.Path, "/") - separatorIndex := strings.Index(fileSystemAndPath, "/") - var fileSystem, path string - if separatorIndex < 0 { - fileSystem = fileSystemAndPath - path = "" - } else { - fileSystem = fileSystemAndPath[0:separatorIndex] - path = fileSystemAndPath[separatorIndex+1:] - } - return &ResourceID{ - AccountName: *accountName, - FileSystemName: fileSystem, - Path: path, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go deleted file mode 100644 index 3ca5674ec31e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/datalakestore/paths/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package paths - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md deleted file mode 100644 index 25474c8bc44d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/README.md +++ /dev/null @@ -1,48 +0,0 @@ -## File Storage Directories SDK for API version 2020-08-04 - -This package allows you to interact with the Directories File Storage API - -### Supported Authorizers - -* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) -* SharedKeyLite (Blob, File & Queue) - -### Limitations - -* At this time the headers `x-ms-file-permission` and `x-ms-file-attributes` are hard-coded (to `inherit` and `None`, respectively). - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - shareName := "myshare" - directoryName := "myfiles" - - storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) - directoriesClient := directories.New() - directoriesClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - metadata := map[string]string{ - "hello": "world", - } - if _, err := directoriesClient.Create(ctx, accountName, shareName, directoryName, metadata); err != nil { - return fmt.Errorf("Error creating Directory: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go deleted file mode 100644 index 2699e668022d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/api.go +++ /dev/null @@ -1,16 +0,0 @@ -package directories - -import ( - "context" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageDirectory interface { - Delete(ctx context.Context, accountName, shareName, path string) (result autorest.Response, err error) - GetMetaData(ctx context.Context, accountName, shareName, path string) (result GetMetaDataResult, err error) - SetMetaData(ctx context.Context, accountName, shareName, path string, metaData map[string]string) (result autorest.Response, err error) - Create(ctx context.Context, accountName, shareName, path string, input CreateDirectoryInput) (result autorest.Response, err error) - GetResourceID(accountName, shareName, directoryName string) string - Get(ctx context.Context, accountName, shareName, path string) (result GetResult, err error) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go deleted file mode 100644 index bf2d315a524d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package directories - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for File Storage Shares. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go deleted file mode 100644 index 37298319be85..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/create.go +++ /dev/null @@ -1,131 +0,0 @@ -package directories - -import ( - "context" - "fmt" - "net/http" - "strings" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type CreateDirectoryInput struct { - // The time at which this file was created at - if omitted, this'll be set to "now" - // This maps to the `x-ms-file-creation-time` field. - // ... Yes I know it says File not Directory, I didn't design the API. - CreatedAt *time.Time - - // The time at which this file was last modified - if omitted, this'll be set to "now" - // This maps to the `x-ms-file-last-write-time` field. - // ... Yes I know it says File not Directory, I didn't design the API. - LastModified *time.Time - - // MetaData is a mapping of key value pairs which should be assigned to this directory - MetaData map[string]string -} - -// Create creates a new directory under the specified share or parent directory. -func (client Client) Create(ctx context.Context, accountName, shareName, path string, input CreateDirectoryInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("directories.Client", "Create", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("directories.Client", "Create", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("directories.Client", "Create", "`shareName` must be a lower-cased string.") - } - if path == "" { - return result, validation.NewError("directories.Client", "Create", "`path` cannot be an empty string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("directories.Client", "Create", fmt.Sprintf("`metadata` is not valid: %s.", err)) - } - - req, err := client.CreatePreparer(ctx, accountName, shareName, path, input) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "directories.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "Create", resp, "Failure responding to request") - return - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName, shareName, path string, input CreateDirectoryInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "directory"), - } - - var coalesceDate = func(input *time.Time, defaultVal string) string { - if input == nil { - return defaultVal - } - - return input.Format(time.RFC1123) - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - - // ... Yes I know these say File not Directory, I didn't design the API. - "x-ms-file-permission": "inherit", // TODO: expose this in future - "x-ms-file-attributes": "None", // TODO: expose this in future - "x-ms-file-creation-time": coalesceDate(input.CreatedAt, "now"), - "x-ms-file-last-write-time": coalesceDate(input.LastModified, "now"), - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go deleted file mode 100644 index 9443c2592983..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/delete.go +++ /dev/null @@ -1,95 +0,0 @@ -package directories - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete removes the specified empty directory -// Note that the directory must be empty before it can be deleted. -func (client Client) Delete(ctx context.Context, accountName, shareName, path string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("directories.Client", "Delete", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("directories.Client", "Delete", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("directories.Client", "Delete", "`shareName` must be a lower-cased string.") - } - if path == "" { - return result, validation.NewError("directories.Client", "Delete", "`path` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, shareName, path) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "directories.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName, shareName, path string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "directory"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go deleted file mode 100644 index 817d680b3fca..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/get.go +++ /dev/null @@ -1,112 +0,0 @@ -package directories - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetResult struct { - autorest.Response - - // A set of name-value pairs that contain metadata for the directory. - MetaData map[string]string - - // The value of this header is set to true if the directory metadata is completely - // encrypted using the specified algorithm. Otherwise, the value is set to false. - DirectoryMetaDataEncrypted bool -} - -// Get returns all system properties for the specified directory, -// and can also be used to check the existence of a directory. -func (client Client) Get(ctx context.Context, accountName, shareName, path string) (result GetResult, err error) { - if accountName == "" { - return result, validation.NewError("directories.Client", "Get", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("directories.Client", "Get", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("directories.Client", "Get", "`shareName` must be a lower-cased string.") - } - if path == "" { - return result, validation.NewError("directories.Client", "Get", "`path` cannot be an empty string.") - } - - req, err := client.GetPreparer(ctx, accountName, shareName, path) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "Get", nil, "Failure preparing request") - return - } - - resp, err := client.GetSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "directories.Client", "Get", resp, "Failure sending request") - return - } - - result, err = client.GetResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "Get", resp, "Failure responding to request") - return - } - - return -} - -// GetPreparer prepares the Get request. -func (client Client) GetPreparer(ctx context.Context, accountName, shareName, path string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "directory"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetResponder handles the response to the Get request. The method always -// closes the http.Response Body. -func (client Client) GetResponder(resp *http.Response) (result GetResult, err error) { - if resp != nil && resp.Header != nil { - result.MetaData = metadata.ParseFromHeaders(resp.Header) - result.DirectoryMetaDataEncrypted = strings.EqualFold(resp.Header.Get("x-ms-server-encrypted"), "true") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go deleted file mode 100644 index 173716de7400..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_get.go +++ /dev/null @@ -1,106 +0,0 @@ -package directories - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetMetaDataResult struct { - autorest.Response - - MetaData map[string]string -} - -// GetMetaData returns all user-defined metadata for the specified directory -func (client Client) GetMetaData(ctx context.Context, accountName, shareName, path string) (result GetMetaDataResult, err error) { - if accountName == "" { - return result, validation.NewError("directories.Client", "GetMetaData", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("directories.Client", "GetMetaData", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("directories.Client", "GetMetaData", "`shareName` must be a lower-cased string.") - } - if path == "" { - return result, validation.NewError("directories.Client", "GetMetaData", "`path` cannot be an empty string.") - } - - req, err := client.GetMetaDataPreparer(ctx, accountName, shareName, path) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "GetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.GetMetaDataSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "directories.Client", "GetMetaData", resp, "Failure sending request") - return - } - - result, err = client.GetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "GetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// GetMetaDataPreparer prepares the GetMetaData request. -func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, shareName, path string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "directory"), - "comp": autorest.Encode("query", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetMetaDataSender sends the GetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetMetaDataResponder handles the response to the GetMetaData request. The method always -// closes the http.Response Body. -func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { - if resp != nil && resp.Header != nil { - result.MetaData = metadata.ParseFromHeaders(resp.Header) - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go deleted file mode 100644 index cb133127da00..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/metadata_set.go +++ /dev/null @@ -1,102 +0,0 @@ -package directories - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -// SetMetaData updates user defined metadata for the specified directory -func (client Client) SetMetaData(ctx context.Context, accountName, shareName, path string, metaData map[string]string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("directories.Client", "SetMetaData", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("directories.Client", "SetMetaData", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("directories.Client", "SetMetaData", "`shareName` must be a lower-cased string.") - } - if path == "" { - return result, validation.NewError("directories.Client", "SetMetaData", "`path` cannot be an empty string.") - } - if err := metadata.Validate(metaData); err != nil { - return result, validation.NewError("directories.Client", "SetMetaData", fmt.Sprintf("`metaData` is not valid: %s.", err)) - } - - req, err := client.SetMetaDataPreparer(ctx, accountName, shareName, path, metaData) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "SetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.SetMetaDataSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "directories.Client", "SetMetaData", resp, "Failure sending request") - return - } - - result, err = client.SetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "directories.Client", "SetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// SetMetaDataPreparer prepares the SetMetaData request. -func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, shareName, path string, metaData map[string]string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "directory"), - "comp": autorest.Encode("query", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = metadata.SetIntoHeaders(headers, metaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetMetaDataSender sends the SetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetMetaDataResponder handles the response to the SetMetaData request. The method always -// closes the http.Response Body. -func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go deleted file mode 100644 index 712ed3a00c39..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/resource_id.go +++ /dev/null @@ -1,56 +0,0 @@ -package directories - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Directory -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, shareName, directoryName string) string { - domain := endpoints.GetFileEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s/%s", domain, shareName, directoryName) -} - -type ResourceID struct { - AccountName string - DirectoryName string - ShareName string -} - -// ParseResourceID parses the Resource ID into an Object -// which can be used to interact with the Directory within the File Share -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.file.core.windows.net/Bar/Folder - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - path := strings.TrimPrefix(uri.Path, "/") - segments := strings.Split(path, "/") - if len(segments) == 0 { - return nil, fmt.Errorf("Expected the path to contain segments but got none") - } - - shareName := segments[0] - directoryName := strings.TrimPrefix(path, shareName) - directoryName = strings.TrimPrefix(directoryName, "/") - return &ResourceID{ - AccountName: *accountName, - ShareName: shareName, - DirectoryName: directoryName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go deleted file mode 100644 index 8446be29ebb2..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/directories/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package directories - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md deleted file mode 100644 index 6ce6bbb13f96..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/README.md +++ /dev/null @@ -1,47 +0,0 @@ -## File Storage Files SDK for API version 2020-08-04 - -This package allows you to interact with the Files File Storage API - -### Supported Authorizers - -* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) -* SharedKeyLite (Blob, File & Queue) - -### Limitations - -* At this time the headers `x-ms-file-permission` and `x-ms-file-attributes` are hard-coded (to `inherit` and `None`, respectively). - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - shareName := "myshare" - directoryName := "myfiles" - fileName := "example.txt" - - storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) - filesClient := files.New() - filesClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - input := files.CreateInput{} - if _, err := filesClient.Create(ctx, accountName, shareName, directoryName, fileName, input); err != nil { - return fmt.Errorf("Error creating File: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go deleted file mode 100644 index 96a0491e70da..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/api.go +++ /dev/null @@ -1,28 +0,0 @@ -package files - -import ( - "context" - "os" - "time" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageFile interface { - PutByteRange(ctx context.Context, accountName, shareName, path, fileName string, input PutByteRangeInput) (result autorest.Response, err error) - GetByteRange(ctx context.Context, accountName, shareName, path, fileName string, input GetByteRangeInput) (result GetByteRangeResult, err error) - ClearByteRange(ctx context.Context, accountName, shareName, path, fileName string, input ClearByteRangeInput) (result autorest.Response, err error) - SetProperties(ctx context.Context, accountName, shareName, path, fileName string, input SetPropertiesInput) (result autorest.Response, err error) - PutFile(ctx context.Context, accountName, shareName, path, fileName string, file *os.File, parallelism int) error - Copy(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput) (result CopyResult, err error) - SetMetaData(ctx context.Context, accountName, shareName, path, fileName string, metaData map[string]string) (result autorest.Response, err error) - GetMetaData(ctx context.Context, accountName, shareName, path, fileName string) (result GetMetaDataResult, err error) - AbortCopy(ctx context.Context, accountName, shareName, path, fileName, copyID string) (result autorest.Response, err error) - GetFile(ctx context.Context, accountName, shareName, path, fileName string, parallelism int) (result autorest.Response, outputBytes []byte, err error) - GetResourceID(accountName, shareName, directoryName, filePath string) string - ListRanges(ctx context.Context, accountName, shareName, path, fileName string) (result ListRangesResult, err error) - GetProperties(ctx context.Context, accountName, shareName, path, fileName string) (result GetResult, err error) - Delete(ctx context.Context, accountName, shareName, path, fileName string) (result autorest.Response, err error) - Create(ctx context.Context, accountName, shareName, path, fileName string, input CreateInput) (result autorest.Response, err error) - CopyAndWait(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput, pollDuration time.Duration) (result CopyResult, err error) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go deleted file mode 100644 index ecca81586b5a..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package files - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for File Storage Shares. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go deleted file mode 100644 index 31768b3d52b7..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy.go +++ /dev/null @@ -1,132 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type CopyInput struct { - // Specifies the URL of the source file or blob, up to 2 KB in length. - // - // To copy a file to another file within the same storage account, you may use Shared Key to authenticate - // the source file. If you are copying a file from another storage account, or if you are copying a blob from - // the same storage account or another storage account, then you must authenticate the source file or blob using a - // shared access signature. If the source is a public blob, no authentication is required to perform the copy - // operation. A file in a share snapshot can also be specified as a copy source. - CopySource string - - MetaData map[string]string -} - -type CopyResult struct { - autorest.Response - - // The CopyID, which can be passed to AbortCopy to abort the copy. - CopyID string - - // Either `success` or `pending` - CopySuccess string -} - -// Copy copies a blob or file to a destination file within the storage account asynchronously. -func (client Client) Copy(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput) (result CopyResult, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "Copy", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "Copy", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "Copy", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "Copy", "`fileName` cannot be an empty string.") - } - if input.CopySource == "" { - return result, validation.NewError("files.Client", "Copy", "`input.CopySource` cannot be an empty string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("files.Client", "Copy", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.CopyPreparer(ctx, accountName, shareName, path, fileName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "Copy", nil, "Failure preparing request") - return - } - - resp, err := client.CopySender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "Copy", resp, "Failure sending request") - return - } - - result, err = client.CopyResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "Copy", resp, "Failure responding to request") - return - } - - return -} - -// CopyPreparer prepares the Copy request. -func (client Client) CopyPreparer(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-copy-source": input.CopySource, - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// CopySender sends the Copy request. The method will close the -// http.Response Body if it receives an error. -func (client Client) CopySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CopyResponder handles the response to the Copy request. The method always -// closes the http.Response Body. -func (client Client) CopyResponder(resp *http.Response) (result CopyResult, err error) { - if resp != nil && resp.Header != nil { - result.CopyID = resp.Header.Get("x-ms-copy-id") - result.CopySuccess = resp.Header.Get("x-ms-copy-status") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go deleted file mode 100644 index 2f0913185888..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_abort.go +++ /dev/null @@ -1,104 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// AbortCopy aborts a pending Copy File operation, and leaves a destination file with zero length and full metadata -func (client Client) AbortCopy(ctx context.Context, accountName, shareName, path, fileName, copyID string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "AbortCopy", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "AbortCopy", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "AbortCopy", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "AbortCopy", "`fileName` cannot be an empty string.") - } - if copyID == "" { - return result, validation.NewError("files.Client", "AbortCopy", "`copyID` cannot be an empty string.") - } - - req, err := client.AbortCopyPreparer(ctx, accountName, shareName, path, fileName, copyID) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "AbortCopy", nil, "Failure preparing request") - return - } - - resp, err := client.AbortCopySender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "AbortCopy", resp, "Failure sending request") - return - } - - result, err = client.AbortCopyResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "AbortCopy", resp, "Failure responding to request") - return - } - - return -} - -// AbortCopyPreparer prepares the AbortCopy request. -func (client Client) AbortCopyPreparer(ctx context.Context, accountName, shareName, path, fileName, copyID string) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "copy"), - "copyid": autorest.Encode("query", copyID), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-copy-action": "abort", - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// AbortCopySender sends the AbortCopy request. The method will close the -// http.Response Body if it receives an error. -func (client Client) AbortCopySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// AbortCopyResponder handles the response to the AbortCopy request. The method always -// closes the http.Response Body. -func (client Client) AbortCopyResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go deleted file mode 100644 index e6a646b1017b..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/copy_wait.go +++ /dev/null @@ -1,55 +0,0 @@ -package files - -import ( - "context" - "fmt" - "strings" - "time" - - "github.com/Azure/go-autorest/autorest" -) - -type CopyAndWaitResult struct { - autorest.Response - - CopyID string -} - -const DefaultCopyPollDuration = 15 * time.Second - -// CopyAndWait is a convenience method which doesn't exist in the API, which copies the file and then waits for the copy to complete -func (client Client) CopyAndWait(ctx context.Context, accountName, shareName, path, fileName string, input CopyInput, pollDuration time.Duration) (result CopyResult, err error) { - copy, e := client.Copy(ctx, accountName, shareName, path, fileName, input) - if err != nil { - result.Response = copy.Response - err = fmt.Errorf("Error copying: %s", e) - return - } - - result.CopyID = copy.CopyID - - // since the API doesn't return a LRO, this is a hack which also polls every 10s, but should be sufficient - for true { - props, e := client.GetProperties(ctx, accountName, shareName, path, fileName) - if e != nil { - result.Response = copy.Response - err = fmt.Errorf("Error waiting for copy: %s", e) - return - } - - switch strings.ToLower(props.CopyStatus) { - case "pending": - time.Sleep(pollDuration) - continue - - case "success": - return - - default: - err = fmt.Errorf("Unexpected CopyState %q", e) - return - } - } - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go deleted file mode 100644 index d2b4ff358120..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/create.go +++ /dev/null @@ -1,169 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type CreateInput struct { - // This header specifies the maximum size for the file, up to 1 TiB. - ContentLength int64 - - // The MIME content type of the file - // If not specified, the default type is application/octet-stream. - ContentType *string - - // Specifies which content encodings have been applied to the file. - // This value is returned to the client when the Get File operation is performed - // on the file resource and can be used to decode file content. - ContentEncoding *string - - // Specifies the natural languages used by this resource. - ContentLanguage *string - - // The File service stores this value but does not use or modify it. - CacheControl *string - - // Sets the file's MD5 hash. - ContentMD5 *string - - // Sets the file’s Content-Disposition header. - ContentDisposition *string - - // The time at which this file was created at - if omitted, this'll be set to "now" - // This maps to the `x-ms-file-creation-time` field. - CreatedAt *time.Time - - // The time at which this file was last modified - if omitted, this'll be set to "now" - // This maps to the `x-ms-file-last-write-time` field. - LastModified *time.Time - - // MetaData is a mapping of key value pairs which should be assigned to this file - MetaData map[string]string -} - -// Create creates a new file or replaces a file. -func (client Client) Create(ctx context.Context, accountName, shareName, path, fileName string, input CreateInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "Create", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "Create", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "Create", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "Create", "`fileName` cannot be an empty string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("files.Client", "Create", "`input.MetaData` cannot be an empty string.") - } - - req, err := client.CreatePreparer(ctx, accountName, shareName, path, fileName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "Create", resp, "Failure responding to request") - return - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName, shareName, path, fileName string, input CreateInput) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - var coalesceDate = func(input *time.Time, defaultVal string) string { - if input == nil { - return defaultVal - } - - return input.Format(time.RFC1123) - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-content-length": input.ContentLength, - "x-ms-type": "file", - - "x-ms-file-permission": "inherit", // TODO: expose this in future - "x-ms-file-attributes": "None", // TODO: expose this in future - "x-ms-file-creation-time": coalesceDate(input.CreatedAt, "now"), - "x-ms-file-last-write-time": coalesceDate(input.LastModified, "now"), - } - - if input.ContentDisposition != nil { - headers["x-ms-content-disposition"] = *input.ContentDisposition - } - - if input.ContentEncoding != nil { - headers["x-ms-content-encoding"] = *input.ContentEncoding - } - - if input.ContentMD5 != nil { - headers["x-ms-content-md5"] = *input.ContentMD5 - } - - if input.ContentType != nil { - headers["x-ms-content-type"] = *input.ContentType - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go deleted file mode 100644 index 5debd767d1fd..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/delete.go +++ /dev/null @@ -1,94 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete immediately deletes the file from the File Share. -func (client Client) Delete(ctx context.Context, accountName, shareName, path, fileName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "Delete", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "Delete", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "Delete", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "Delete", "`fileName` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, shareName, path, fileName) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go deleted file mode 100644 index fd62f90aec8f..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_get.go +++ /dev/null @@ -1,111 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetMetaDataResult struct { - autorest.Response - - MetaData map[string]string -} - -// GetMetaData returns the MetaData for the specified File. -func (client Client) GetMetaData(ctx context.Context, accountName, shareName, path, fileName string) (result GetMetaDataResult, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "GetMetaData", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "GetMetaData", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "GetMetaData", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "GetMetaData", "`fileName` cannot be an empty string.") - } - - req, err := client.GetMetaDataPreparer(ctx, accountName, shareName, path, fileName) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "GetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.GetMetaDataSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "GetMetaData", resp, "Failure sending request") - return - } - - result, err = client.GetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "GetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// GetMetaDataPreparer prepares the GetMetaData request. -func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetMetaDataSender sends the GetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetMetaDataResponder handles the response to the GetMetaData request. The method always -// closes the http.Response Body. -func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { - if resp != nil && resp.Header != nil { - result.MetaData = metadata.ParseFromHeaders(resp.Header) - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - //metadata.ByParsingFromHeaders(&result.MetaData), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go deleted file mode 100644 index 41e3ffcb8ff9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/metadata_set.go +++ /dev/null @@ -1,105 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -// SetMetaData updates the specified File to have the specified MetaData. -func (client Client) SetMetaData(ctx context.Context, accountName, shareName, path, fileName string, metaData map[string]string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "SetMetaData", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "SetMetaData", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "SetMetaData", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "SetMetaData", "`fileName` cannot be an empty string.") - } - if err := metadata.Validate(metaData); err != nil { - return result, validation.NewError("files.Client", "SetMetaData", fmt.Sprintf("`metaData` is not valid: %s.", err)) - } - - req, err := client.SetMetaDataPreparer(ctx, accountName, shareName, path, fileName, metaData) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "SetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.SetMetaDataSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "SetMetaData", resp, "Failure sending request") - return - } - - result, err = client.SetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "SetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// SetMetaDataPreparer prepares the SetMetaData request. -func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, shareName, path, fileName string, metaData map[string]string) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = metadata.SetIntoHeaders(headers, metaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetMetaDataSender sends the SetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetMetaDataResponder handles the response to the SetMetaData request. The method always -// closes the http.Response Body. -func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go deleted file mode 100644 index c6a0c399d2d7..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_get.go +++ /dev/null @@ -1,144 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strconv" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetResult struct { - autorest.Response - - CacheControl string - ContentDisposition string - ContentEncoding string - ContentLanguage string - ContentLength *int64 - ContentMD5 string - ContentType string - CopyID string - CopyStatus string - CopySource string - CopyProgress string - CopyStatusDescription string - CopyCompletionTime string - Encrypted bool - - MetaData map[string]string -} - -// GetProperties returns the Properties for the specified file -func (client Client) GetProperties(ctx context.Context, accountName, shareName, path, fileName string) (result GetResult, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "GetProperties", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "GetProperties", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "GetProperties", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "GetProperties", "`fileName` cannot be an empty string.") - } - - req, err := client.GetPropertiesPreparer(ctx, accountName, shareName, path, fileName) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "GetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetPropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "GetProperties", resp, "Failure sending request") - return - } - - result, err = client.GetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "GetProperties", resp, "Failure responding to request") - return - } - - return -} - -// GetPropertiesPreparer prepares the GetProperties request. -func (client Client) GetPropertiesPreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsHead(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetPropertiesResponder handles the response to the GetProperties request. The method always -// closes the http.Response Body. -func (client Client) GetPropertiesResponder(resp *http.Response) (result GetResult, err error) { - if resp != nil && resp.Header != nil { - result.CacheControl = resp.Header.Get("Cache-Control") - result.ContentDisposition = resp.Header.Get("Content-Disposition") - result.ContentEncoding = resp.Header.Get("Content-Encoding") - result.ContentLanguage = resp.Header.Get("Content-Language") - result.ContentMD5 = resp.Header.Get("x-ms-content-md5") - result.ContentType = resp.Header.Get("Content-Type") - result.CopyID = resp.Header.Get("x-ms-copy-id") - result.CopyProgress = resp.Header.Get("x-ms-copy-progress") - result.CopySource = resp.Header.Get("x-ms-copy-source") - result.CopyStatus = resp.Header.Get("x-ms-copy-status") - result.CopyStatusDescription = resp.Header.Get("x-ms-copy-status-description") - result.CopyCompletionTime = resp.Header.Get("x-ms-copy-completion-time") - result.Encrypted = strings.EqualFold(resp.Header.Get("x-ms-server-encrypted"), "true") - result.MetaData = metadata.ParseFromHeaders(resp.Header) - - contentLengthRaw := resp.Header.Get("Content-Length") - if contentLengthRaw != "" { - contentLength, err := strconv.Atoi(contentLengthRaw) - if err != nil { - return result, fmt.Errorf("Error parsing %q for Content-Length as an integer: %s", contentLengthRaw, err) - } - contentLengthI64 := int64(contentLength) - result.ContentLength = &contentLengthI64 - } - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go deleted file mode 100644 index 521b1bba7be7..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/properties_set.go +++ /dev/null @@ -1,186 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type SetPropertiesInput struct { - // Resizes a file to the specified size. - // If the specified byte value is less than the current size of the file, - // then all ranges above the specified byte value are cleared. - ContentLength int64 - - // Modifies the cache control string for the file. - // If this property is not specified on the request, then the property will be cleared for the file. - // Subsequent calls to Get File Properties will not return this property, - // unless it is explicitly set on the file again. - ContentControl *string - - // Sets the file’s Content-Disposition header. - // If this property is not specified on the request, then the property will be cleared for the file. - // Subsequent calls to Get File Properties will not return this property, - // unless it is explicitly set on the file again. - ContentDisposition *string - - // Sets the file's content encoding. - // If this property is not specified on the request, then the property will be cleared for the file. - // Subsequent calls to Get File Properties will not return this property, - // unless it is explicitly set on the file again. - ContentEncoding *string - - // Sets the file's content language. - // If this property is not specified on the request, then the property will be cleared for the file. - // Subsequent calls to Get File Properties will not return this property, - // unless it is explicitly set on the file again. - ContentLanguage *string - - // Sets the file's MD5 hash. - // If this property is not specified on the request, then the property will be cleared for the file. - // Subsequent calls to Get File Properties will not return this property, - // unless it is explicitly set on the file again. - ContentMD5 *string - - // Sets the file's content type. - // If this property is not specified on the request, then the property will be cleared for the file. - // Subsequent calls to Get File Properties will not return this property, - // unless it is explicitly set on the file again. - ContentType *string - - // The time at which this file was created at - if omitted, this'll be set to "now" - // This maps to the `x-ms-file-creation-time` field. - CreatedAt *time.Time - - // The time at which this file was last modified - if omitted, this'll be set to "now" - // This maps to the `x-ms-file-last-write-time` field. - LastModified *time.Time - - // MetaData is a mapping of key value pairs which should be assigned to this file - MetaData map[string]string -} - -// SetProperties sets the specified properties on the specified File -func (client Client) SetProperties(ctx context.Context, accountName, shareName, path, fileName string, input SetPropertiesInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "SetProperties", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "SetProperties", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "SetProperties", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "SetProperties", "`fileName` cannot be an empty string.") - } - - req, err := client.SetPropertiesPreparer(ctx, accountName, shareName, path, fileName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "SetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.SetPropertiesSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "SetProperties", resp, "Failure sending request") - return - } - - result, err = client.SetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "SetProperties", resp, "Failure responding to request") - return - } - - return -} - -// SetPropertiesPreparer prepares the SetProperties request. -func (client Client) SetPropertiesPreparer(ctx context.Context, accountName, shareName, path, fileName string, input SetPropertiesInput) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - var coalesceDate = func(input *time.Time, defaultVal string) string { - if input == nil { - return defaultVal - } - - return input.Format(time.RFC1123) - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-type": "file", - - "x-ms-content-length": input.ContentLength, - "x-ms-file-permission": "inherit", // TODO: expose this in future - "x-ms-file-attributes": "None", // TODO: expose this in future - "x-ms-file-creation-time": coalesceDate(input.CreatedAt, "now"), - "x-ms-file-last-write-time": coalesceDate(input.LastModified, "now"), - } - - if input.ContentControl != nil { - headers["x-ms-cache-control"] = *input.ContentControl - } - if input.ContentDisposition != nil { - headers["x-ms-content-disposition"] = *input.ContentDisposition - } - if input.ContentEncoding != nil { - headers["x-ms-content-encoding"] = *input.ContentEncoding - } - if input.ContentLanguage != nil { - headers["x-ms-content-language"] = *input.ContentLanguage - } - if input.ContentMD5 != nil { - headers["x-ms-content-md5"] = *input.ContentMD5 - } - if input.ContentType != nil { - headers["x-ms-content-type"] = *input.ContentType - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetPropertiesSender sends the SetProperties request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetPropertiesResponder handles the response to the SetProperties request. The method always -// closes the http.Response Body. -func (client Client) SetPropertiesResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go deleted file mode 100644 index 5d8145fae422..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_clear.go +++ /dev/null @@ -1,112 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type ClearByteRangeInput struct { - StartBytes int64 - EndBytes int64 -} - -// ClearByteRange clears the specified Byte Range from within the specified File -func (client Client) ClearByteRange(ctx context.Context, accountName, shareName, path, fileName string, input ClearByteRangeInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "ClearByteRange", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "ClearByteRange", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "ClearByteRange", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "ClearByteRange", "`fileName` cannot be an empty string.") - } - if input.StartBytes < 0 { - return result, validation.NewError("files.Client", "ClearByteRange", "`input.StartBytes` must be greater or equal to 0.") - } - if input.EndBytes <= 0 { - return result, validation.NewError("files.Client", "ClearByteRange", "`input.EndBytes` must be greater than 0.") - } - - req, err := client.ClearByteRangePreparer(ctx, accountName, shareName, path, fileName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "ClearByteRange", nil, "Failure preparing request") - return - } - - resp, err := client.ClearByteRangeSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "ClearByteRange", resp, "Failure sending request") - return - } - - result, err = client.ClearByteRangeResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "ClearByteRange", resp, "Failure responding to request") - return - } - - return -} - -// ClearByteRangePreparer prepares the ClearByteRange request. -func (client Client) ClearByteRangePreparer(ctx context.Context, accountName, shareName, path, fileName string, input ClearByteRangeInput) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "range"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-write": "clear", - "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartBytes, input.EndBytes), - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ClearByteRangeSender sends the ClearByteRange request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ClearByteRangeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ClearByteRangeResponder handles the response to the ClearByteRange request. The method always -// closes the http.Response Body. -func (client Client) ClearByteRangeResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go deleted file mode 100644 index 733d3f525105..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get.go +++ /dev/null @@ -1,121 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetByteRangeInput struct { - StartBytes int64 - EndBytes int64 -} - -type GetByteRangeResult struct { - autorest.Response - - Contents []byte -} - -// GetByteRange returns the specified Byte Range from the specified File. -func (client Client) GetByteRange(ctx context.Context, accountName, shareName, path, fileName string, input GetByteRangeInput) (result GetByteRangeResult, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "GetByteRange", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "GetByteRange", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "GetByteRange", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "GetByteRange", "`fileName` cannot be an empty string.") - } - if input.StartBytes < 0 { - return result, validation.NewError("files.Client", "GetByteRange", "`input.StartBytes` must be greater or equal to 0.") - } - if input.EndBytes <= 0 { - return result, validation.NewError("files.Client", "GetByteRange", "`input.EndBytes` must be greater than 0.") - } - expectedBytes := input.EndBytes - input.StartBytes - if expectedBytes < (4 * 1024) { - return result, validation.NewError("files.Client", "GetByteRange", "Requested Byte Range must be at least 4KB.") - } - if expectedBytes > (4 * 1024 * 1024) { - return result, validation.NewError("files.Client", "GetByteRange", "Requested Byte Range must be at most 4MB.") - } - - req, err := client.GetByteRangePreparer(ctx, accountName, shareName, path, fileName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "GetByteRange", nil, "Failure preparing request") - return - } - - resp, err := client.GetByteRangeSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "GetByteRange", resp, "Failure sending request") - return - } - - result, err = client.GetByteRangeResponder(resp, expectedBytes) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "GetByteRange", resp, "Failure responding to request") - return - } - - return -} - -// GetByteRangePreparer prepares the GetByteRange request. -func (client Client) GetByteRangePreparer(ctx context.Context, accountName, shareName, path, fileName string, input GetByteRangeInput) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartBytes, input.EndBytes-1), - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetByteRangeSender sends the GetByteRange request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetByteRangeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetByteRangeResponder handles the response to the GetByteRange request. The method always -// closes the http.Response Body. -func (client Client) GetByteRangeResponder(resp *http.Response, length int64) (result GetByteRangeResult, err error) { - result.Contents = make([]byte, length) - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusPartialContent), - autorest.ByUnmarshallingBytes(&result.Contents), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go deleted file mode 100644 index 9e5be17f85fc..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_get_file.go +++ /dev/null @@ -1,128 +0,0 @@ -package files - -import ( - "context" - "fmt" - "log" - "math" - "runtime" - "sync" - - "github.com/Azure/go-autorest/autorest" -) - -// GetFile is a helper method to download a file by chunking it automatically -func (client Client) GetFile(ctx context.Context, accountName, shareName, path, fileName string, parallelism int) (result autorest.Response, outputBytes []byte, err error) { - - // first look up the file and check out how many bytes it is - file, e := client.GetProperties(ctx, accountName, shareName, path, fileName) - if err != nil { - result = file.Response - err = e - return - } - - if file.ContentLength == nil { - err = fmt.Errorf("Content-Length was nil!") - return - } - - length := int64(*file.ContentLength) - chunkSize := int64(4 * 1024 * 1024) // 4MB - - if chunkSize > length { - chunkSize = length - } - - // then split that up into chunks and retrieve it retrieve it into the 'results' set - chunks := int(math.Ceil(float64(length) / float64(chunkSize))) - workerCount := parallelism * runtime.NumCPU() - if workerCount > chunks { - workerCount = chunks - } - - var waitGroup sync.WaitGroup - waitGroup.Add(workerCount) - - results := make([]*downloadFileChunkResult, chunks) - errors := make(chan error, chunkSize) - - for i := 0; i < chunks; i++ { - go func(i int) { - log.Printf("[DEBUG] Downloading Chunk %d of %d", i+1, chunks) - - dfci := downloadFileChunkInput{ - thisChunk: i, - chunkSize: chunkSize, - fileSize: length, - } - - result, err := client.downloadFileChunk(ctx, accountName, shareName, path, fileName, dfci) - if err != nil { - errors <- err - waitGroup.Done() - return - } - - // if there's no error, we should have bytes, so this is safe - results[i] = result - - waitGroup.Done() - }(i) - } - waitGroup.Wait() - - // TODO: we should switch to hashicorp/multi-error here - if len(errors) > 0 { - err = fmt.Errorf("Error downloading file: %s", <-errors) - return - } - - // then finally put it all together, in order and return it - output := make([]byte, length) - for _, v := range results { - copy(output[v.startBytes:v.endBytes], v.bytes) - } - - outputBytes = output - return -} - -type downloadFileChunkInput struct { - thisChunk int - chunkSize int64 - fileSize int64 -} - -type downloadFileChunkResult struct { - startBytes int64 - endBytes int64 - bytes []byte -} - -func (client Client) downloadFileChunk(ctx context.Context, accountName, shareName, path, fileName string, input downloadFileChunkInput) (*downloadFileChunkResult, error) { - startBytes := input.chunkSize * int64(input.thisChunk) - endBytes := startBytes + input.chunkSize - - // the last chunk may exceed the size of the file - remaining := input.fileSize - startBytes - if input.chunkSize > remaining { - endBytes = startBytes + remaining - } - - getInput := GetByteRangeInput{ - StartBytes: startBytes, - EndBytes: endBytes, - } - result, err := client.GetByteRange(ctx, accountName, shareName, path, fileName, getInput) - if err != nil { - return nil, fmt.Errorf("Error putting bytes: %s", err) - } - - output := downloadFileChunkResult{ - startBytes: startBytes, - endBytes: endBytes, - bytes: result.Contents, - } - return &output, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go deleted file mode 100644 index 20e4d398d590..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put.go +++ /dev/null @@ -1,127 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type PutByteRangeInput struct { - StartBytes int64 - EndBytes int64 - - // Content is the File Contents for the specified range - // which can be at most 4MB - Content []byte -} - -// PutByteRange puts the specified Byte Range in the specified File. -func (client Client) PutByteRange(ctx context.Context, accountName, shareName, path, fileName string, input PutByteRangeInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "PutByteRange", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "PutByteRange", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "PutByteRange", "`shareName` must be a lower-cased string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "PutByteRange", "`fileName` cannot be an empty string.") - } - if input.StartBytes < 0 { - return result, validation.NewError("files.Client", "PutByteRange", "`input.StartBytes` must be greater or equal to 0.") - } - if input.EndBytes <= 0 { - return result, validation.NewError("files.Client", "PutByteRange", "`input.EndBytes` must be greater than 0.") - } - - expectedBytes := input.EndBytes - input.StartBytes - actualBytes := len(input.Content) - if expectedBytes != int64(actualBytes) { - return result, validation.NewError("files.Client", "PutByteRange", fmt.Sprintf("The specified byte-range (%d) didn't match the content size (%d).", expectedBytes, actualBytes)) - } - - if expectedBytes > (4 * 1024 * 1024) { - return result, validation.NewError("files.Client", "PutByteRange", "Specified Byte Range must be at most 4MB.") - } - - req, err := client.PutByteRangePreparer(ctx, accountName, shareName, path, fileName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "PutByteRange", nil, "Failure preparing request") - return - } - - resp, err := client.PutByteRangeSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "PutByteRange", resp, "Failure sending request") - return - } - - result, err = client.PutByteRangeResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "PutByteRange", resp, "Failure responding to request") - return - } - - return -} - -// PutByteRangePreparer prepares the PutByteRange request. -func (client Client) PutByteRangePreparer(ctx context.Context, accountName, shareName, path, fileName string, input PutByteRangeInput) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "range"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-write": "update", - "x-ms-range": fmt.Sprintf("bytes=%d-%d", input.StartBytes, input.EndBytes-1), - "Content-Length": int(len(input.Content)), - } - - preparer := autorest.CreatePreparer( - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters), - autorest.WithBytes(&input.Content)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// PutByteRangeSender sends the PutByteRange request. The method will close the -// http.Response Body if it receives an error. -func (client Client) PutByteRangeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// PutByteRangeResponder handles the response to the PutByteRange request. The method always -// closes the http.Response Body. -func (client Client) PutByteRangeResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go deleted file mode 100644 index a39cd377cee8..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/range_put_file.go +++ /dev/null @@ -1,107 +0,0 @@ -package files - -import ( - "context" - "fmt" - "io" - "log" - "math" - "os" - "runtime" - "sync" - - "github.com/Azure/go-autorest/autorest" -) - -// PutFile is a helper method which takes a file, and automatically chunks it up, rather than having to do this yourself -func (client Client) PutFile(ctx context.Context, accountName, shareName, path, fileName string, file *os.File, parallelism int) error { - fileInfo, err := file.Stat() - if err != nil { - return fmt.Errorf("Error loading file info: %s", err) - } - - fileSize := fileInfo.Size() - chunkSize := 4 * 1024 * 1024 // 4MB - if chunkSize > int(fileSize) { - chunkSize = int(fileSize) - } - chunks := int(math.Ceil(float64(fileSize) / float64(chunkSize*1.0))) - - workerCount := parallelism * runtime.NumCPU() - if workerCount > chunks { - workerCount = chunks - } - - var waitGroup sync.WaitGroup - waitGroup.Add(workerCount) - errors := make(chan error, chunkSize) - - for i := 0; i < chunks; i++ { - go func(i int) { - log.Printf("[DEBUG] Chunk %d of %d", i+1, chunks) - - uci := uploadChunkInput{ - thisChunk: i, - chunkSize: chunkSize, - fileSize: fileSize, - } - - _, err := client.uploadChunk(ctx, accountName, shareName, path, fileName, uci, file) - if err != nil { - errors <- err - waitGroup.Done() - return - } - - waitGroup.Done() - return - }(i) - } - waitGroup.Wait() - - // TODO: we should switch to hashicorp/multi-error here - if len(errors) > 0 { - return fmt.Errorf("Error uploading file: %s", <-errors) - } - - return nil -} - -type uploadChunkInput struct { - thisChunk int - chunkSize int - fileSize int64 -} - -func (client Client) uploadChunk(ctx context.Context, accountName, shareName, path, fileName string, input uploadChunkInput, file *os.File) (result autorest.Response, err error) { - startBytes := int64(input.chunkSize * input.thisChunk) - endBytes := startBytes + int64(input.chunkSize) - - // the last size may exceed the size of the file - remaining := input.fileSize - startBytes - if int64(input.chunkSize) > remaining { - endBytes = startBytes + remaining - } - - bytesToRead := int(endBytes) - int(startBytes) - bytes := make([]byte, bytesToRead) - - _, err = file.ReadAt(bytes, startBytes) - if err != nil { - if err != io.EOF { - return result, fmt.Errorf("Error reading bytes: %s", err) - } - } - - putBytesInput := PutByteRangeInput{ - StartBytes: startBytes, - EndBytes: endBytes, - Content: bytes, - } - result, err = client.PutByteRange(ctx, accountName, shareName, path, fileName, putBytesInput) - if err != nil { - return result, fmt.Errorf("Error putting bytes: %s", err) - } - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go deleted file mode 100644 index ea309f97ddb2..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/ranges_list.go +++ /dev/null @@ -1,114 +0,0 @@ -package files - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type ListRangesResult struct { - autorest.Response - - Ranges []Range `xml:"Range"` -} - -type Range struct { - Start string `xml:"Start"` - End string `xml:"End"` -} - -// ListRanges returns the list of valid ranges for the specified File. -func (client Client) ListRanges(ctx context.Context, accountName, shareName, path, fileName string) (result ListRangesResult, err error) { - if accountName == "" { - return result, validation.NewError("files.Client", "ListRanges", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("files.Client", "ListRanges", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("files.Client", "ListRanges", "`shareName` must be a lower-cased string.") - } - if path == "" { - return result, validation.NewError("files.Client", "ListRanges", "`path` cannot be an empty string.") - } - if fileName == "" { - return result, validation.NewError("files.Client", "ListRanges", "`fileName` cannot be an empty string.") - } - - req, err := client.ListRangesPreparer(ctx, accountName, shareName, path, fileName) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "ListRanges", nil, "Failure preparing request") - return - } - - resp, err := client.ListRangesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "files.Client", "ListRanges", resp, "Failure sending request") - return - } - - result, err = client.ListRangesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "files.Client", "ListRanges", resp, "Failure responding to request") - return - } - - return -} - -// ListRangesPreparer prepares the ListRanges request. -func (client Client) ListRangesPreparer(ctx context.Context, accountName, shareName, path, fileName string) (*http.Request, error) { - if path != "" { - path = fmt.Sprintf("%s/", path) - } - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - "directory": autorest.Encode("path", path), - "fileName": autorest.Encode("path", fileName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "rangelist"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}/{directory}{fileName}", pathParameters), - autorest.WithHeaders(headers), - autorest.WithQueryParameters(queryParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ListRangesSender sends the ListRanges request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ListRangesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ListRangesResponder handles the response to the ListRanges request. The method always -// closes the http.Response Body. -func (client Client) ListRangesResponder(resp *http.Response) (result ListRangesResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go deleted file mode 100644 index f18e702e81d9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/resource_id.go +++ /dev/null @@ -1,64 +0,0 @@ -package files - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given File -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, shareName, directoryName, filePath string) string { - domain := endpoints.GetFileEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s/%s/%s", domain, shareName, directoryName, filePath) -} - -type ResourceID struct { - AccountName string - DirectoryName string - FileName string - ShareName string -} - -// ParseResourceID parses the specified Resource ID and returns an object -// which can be used to interact with Files within a Storage Share. -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://account1.file.core.chinacloudapi.cn/share1/directory1/file1.txt - // example: https://account1.file.core.chinacloudapi.cn/share1/directory1/directory2/file1.txt - - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - path := strings.TrimPrefix(uri.Path, "/") - segments := strings.Split(path, "/") - if len(segments) == 0 { - return nil, fmt.Errorf("Expected the path to contain segments but got none") - } - - shareName := segments[0] - fileName := segments[len(segments)-1] - - directoryName := strings.TrimPrefix(path, shareName) - directoryName = strings.TrimPrefix(directoryName, "/") - directoryName = strings.TrimSuffix(directoryName, fileName) - directoryName = strings.TrimSuffix(directoryName, "/") - return &ResourceID{ - AccountName: *accountName, - ShareName: shareName, - DirectoryName: directoryName, - FileName: fileName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go deleted file mode 100644 index 7c8231033703..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/files/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package files - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md deleted file mode 100644 index ecc0f13ae9bb..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/README.md +++ /dev/null @@ -1,43 +0,0 @@ -## File Storage Shares SDK for API version 2020-08-04 - -This package allows you to interact with the Shares File Storage API - -### Supported Authorizers - -* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) -* SharedKeyLite (Blob, File & Queue) - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - shareName := "myshare" - - storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) - sharesClient := shares.New() - sharesClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - input := shares.CreateInput{ - QuotaInGB: 2, - } - if _, err := sharesClient.Create(ctx, accountName, shareName, input); err != nil { - return fmt.Errorf("Error creating Share: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go deleted file mode 100644 index ea6ff4c2dd26..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_get.go +++ /dev/null @@ -1,98 +0,0 @@ -package shares - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetACLResult struct { - autorest.Response - - SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` -} - -// GetACL get the Access Control List for the specified Storage Share -func (client Client) GetACL(ctx context.Context, accountName, shareName string) (result GetACLResult, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "GetACL", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "GetACL", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "GetACL", "`shareName` must be a lower-cased string.") - } - - req, err := client.GetACLPreparer(ctx, accountName, shareName) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetACL", nil, "Failure preparing request") - return - } - - resp, err := client.GetACLSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "GetACL", resp, "Failure sending request") - return - } - - result, err = client.GetACLResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetACL", resp, "Failure responding to request") - return - } - - return -} - -// GetACLPreparer prepares the GetACL request. -func (client Client) GetACLPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - "comp": autorest.Encode("query", "acl"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetACLSender sends the GetACL request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetACLSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetACLResponder handles the response to the GetACL request. The method always -// closes the http.Response Body. -func (client Client) GetACLResponder(resp *http.Response) (result GetACLResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go deleted file mode 100644 index 18d1788a2ee4..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/acl_set.go +++ /dev/null @@ -1,103 +0,0 @@ -package shares - -import ( - "context" - "encoding/xml" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type setAcl struct { - SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` - - XMLName xml.Name `xml:"SignedIdentifiers"` -} - -// SetACL sets the specified Access Control List on the specified Storage Share -func (client Client) SetACL(ctx context.Context, accountName, shareName string, acls []SignedIdentifier) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "SetACL", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "SetACL", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "SetACL", "`shareName` must be a lower-cased string.") - } - - req, err := client.SetACLPreparer(ctx, accountName, shareName, acls) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "SetACL", nil, "Failure preparing request") - return - } - - resp, err := client.SetACLSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "SetACL", resp, "Failure sending request") - return - } - - result, err = client.SetACLResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "SetACL", resp, "Failure responding to request") - return - } - - return -} - -// SetACLPreparer prepares the SetACL request. -func (client Client) SetACLPreparer(ctx context.Context, accountName, shareName string, acls []SignedIdentifier) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - "comp": autorest.Encode("query", "acl"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - input := setAcl{ - SignedIdentifiers: acls, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers), - autorest.WithXML(&input)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetACLSender sends the SetACL request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetACLSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetACLResponder handles the response to the SetACL request. The method always -// closes the http.Response Body. -func (client Client) SetACLResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go deleted file mode 100644 index 62389b4c0a98..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/api.go +++ /dev/null @@ -1,24 +0,0 @@ -package shares - -import ( - "context" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageShare interface { - SetACL(ctx context.Context, accountName, shareName string, acls []SignedIdentifier) (result autorest.Response, err error) - GetSnapshot(ctx context.Context, accountName, shareName, snapshotShare string) (result GetSnapshotPropertiesResult, err error) - GetStats(ctx context.Context, accountName, shareName string) (result GetStatsResult, err error) - GetACL(ctx context.Context, accountName, shareName string) (result GetACLResult, err error) - SetMetaData(ctx context.Context, accountName, shareName string, metaData map[string]string) (result autorest.Response, err error) - GetMetaData(ctx context.Context, accountName, shareName string) (result GetMetaDataResult, err error) - SetProperties(ctx context.Context, accountName, shareName string, newQuotaGB int) (result autorest.Response, err error) - DeleteSnapshot(ctx context.Context, accountName, shareName string, shareSnapshot string) (result autorest.Response, err error) - CreateSnapshot(ctx context.Context, accountName, shareName string, input CreateSnapshotInput) (result CreateSnapshotResult, err error) - GetResourceID(accountName, shareName string) string - GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, shareName string) string - GetProperties(ctx context.Context, accountName, shareName string) (result GetPropertiesResult, err error) - Delete(ctx context.Context, accountName, shareName string, deleteSnapshots bool) (result autorest.Response, err error) - Create(ctx context.Context, accountName, shareName string, input CreateInput) (result autorest.Response, err error) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go deleted file mode 100644 index 4f3a6f9f99d0..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package shares - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for File Storage Shares. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go deleted file mode 100644 index 0124e81ec128..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/create.go +++ /dev/null @@ -1,109 +0,0 @@ -package shares - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type CreateInput struct { - // Specifies the maximum size of the share, in gigabytes. - // Must be greater than 0, and less than or equal to 5TB (5120). - QuotaInGB int - - MetaData map[string]string -} - -// Create creates the specified Storage Share within the specified Storage Account -func (client Client) Create(ctx context.Context, accountName, shareName string, input CreateInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "Create", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "Create", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "Create", "`shareName` must be a lower-cased string.") - } - if input.QuotaInGB <= 0 || input.QuotaInGB > 102400 { - return result, validation.NewError("shares.Client", "Create", "`input.QuotaInGB` must be greater than 0, and less than/equal to 100TB (102400 GB)") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("shares.Client", "Create", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.CreatePreparer(ctx, accountName, shareName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "Create", resp, "Failure responding to request") - return - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName, shareName string, input CreateInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "share"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-share-quota": input.QuotaInGB, - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go deleted file mode 100644 index 70ef985d23bb..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/delete.go +++ /dev/null @@ -1,94 +0,0 @@ -package shares - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete deletes the specified Storage Share from within a Storage Account -func (client Client) Delete(ctx context.Context, accountName, shareName string, deleteSnapshots bool) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "Delete", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "Delete", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "Delete", "`shareName` must be a lower-cased string.") - } - - req, err := client.DeletePreparer(ctx, accountName, shareName, deleteSnapshots) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName, shareName string, deleteSnapshots bool) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "share"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - if deleteSnapshots { - headers["x-ms-delete-snapshots"] = "include" - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go deleted file mode 100644 index 9fa4d9f07ed8..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_get.go +++ /dev/null @@ -1,102 +0,0 @@ -package shares - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetMetaDataResult struct { - autorest.Response - - MetaData map[string]string -} - -// GetMetaData returns the MetaData associated with the specified Storage Share -func (client Client) GetMetaData(ctx context.Context, accountName, shareName string) (result GetMetaDataResult, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "GetMetaData", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "GetMetaData", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "GetMetaData", "`shareName` must be a lower-cased string.") - } - - req, err := client.GetMetaDataPreparer(ctx, accountName, shareName) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.GetMetaDataSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "GetMetaData", resp, "Failure sending request") - return - } - - result, err = client.GetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// GetMetaDataPreparer prepares the GetMetaData request. -func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - "comp": autorest.Encode("query", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetMetaDataSender sends the GetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetMetaDataResponder handles the response to the GetMetaData request. The method always -// closes the http.Response Body. -func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { - if resp.Header != nil { - result.MetaData = metadata.ParseFromHeaders(resp.Header) - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go deleted file mode 100644 index 7e64e60aca15..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/metadata_set.go +++ /dev/null @@ -1,97 +0,0 @@ -package shares - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -// SetMetaData sets the MetaData on the specified Storage Share -func (client Client) SetMetaData(ctx context.Context, accountName, shareName string, metaData map[string]string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "SetMetaData", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "SetMetaData", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "SetMetaData", "`shareName` must be a lower-cased string.") - } - if err := metadata.Validate(metaData); err != nil { - return result, validation.NewError("shares.Client", "SetMetaData", fmt.Sprintf("`metadata` is not valid: %s.", err)) - } - - req, err := client.SetMetaDataPreparer(ctx, accountName, shareName, metaData) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "SetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.SetMetaDataSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "SetMetaData", resp, "Failure sending request") - return - } - - result, err = client.SetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "SetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// SetMetaDataPreparer prepares the SetMetaData request. -func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, shareName string, metaData map[string]string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - "comp": autorest.Encode("query", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - headers = metadata.SetIntoHeaders(headers, metaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetPropertiesSetMetaDataSender sends the SetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetMetaDataResponder handles the response to the SetMetaData request. The method always -// closes the http.Response Body. -func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go deleted file mode 100644 index 31ef7c204703..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/models.go +++ /dev/null @@ -1,12 +0,0 @@ -package shares - -type SignedIdentifier struct { - Id string `xml:"Id"` - AccessPolicy AccessPolicy `xml:"AccessPolicy"` -} - -type AccessPolicy struct { - Start string `xml:"Start"` - Expiry string `xml:"Expiry"` - Permission string `xml:"Permission"` -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go deleted file mode 100644 index 95fa58de2c8c..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_get.go +++ /dev/null @@ -1,113 +0,0 @@ -package shares - -import ( - "context" - "fmt" - "net/http" - "strconv" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetPropertiesResult struct { - autorest.Response - - MetaData map[string]string - ShareQuota int -} - -// GetProperties returns the properties about the specified Storage Share -func (client Client) GetProperties(ctx context.Context, accountName, shareName string) (result GetPropertiesResult, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "GetProperties", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "GetProperties", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "GetProperties", "`shareName` must be a lower-cased string.") - } - - req, err := client.GetPropertiesPreparer(ctx, accountName, shareName) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetPropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "GetProperties", resp, "Failure sending request") - return - } - - result, err = client.GetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetProperties", resp, "Failure responding to request") - return - } - - return -} - -// GetPropertiesPreparer prepares the GetProperties request. -func (client Client) GetPropertiesPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) GetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetPropertiesResponder handles the response to the GetProperties request. The method always -// closes the http.Response Body. -func (client Client) GetPropertiesResponder(resp *http.Response) (result GetPropertiesResult, err error) { - if resp.Header != nil { - result.MetaData = metadata.ParseFromHeaders(resp.Header) - - quotaRaw := resp.Header.Get("x-ms-share-quota") - if quotaRaw != "" { - quota, e := strconv.Atoi(quotaRaw) - if e != nil { - return result, fmt.Errorf("Error converting %q to an integer: %s", quotaRaw, err) - } - result.ShareQuota = quota - } - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go deleted file mode 100644 index b0f833674ec1..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/properties_set.go +++ /dev/null @@ -1,95 +0,0 @@ -package shares - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// SetProperties lets you update the Quota for the specified Storage Share -func (client Client) SetProperties(ctx context.Context, accountName, shareName string, newQuotaGB int) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "SetProperties", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "SetProperties", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "SetProperties", "`shareName` must be a lower-cased string.") - } - if newQuotaGB <= 0 || newQuotaGB > 102400 { - return result, validation.NewError("shares.Client", "SetProperties", "`newQuotaGB` must be greater than 0, and less than/equal to 100TB (102400 GB)") - } - - req, err := client.SetPropertiesPreparer(ctx, accountName, shareName, newQuotaGB) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "SetProperties", nil, "Failure preparing request") - return - } - - resp, err := client.SetPropertiesSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "SetProperties", resp, "Failure sending request") - return - } - - result, err = client.SetPropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "SetProperties", resp, "Failure responding to request") - return - } - - return -} - -// SetPropertiesPreparer prepares the SetProperties request. -func (client Client) SetPropertiesPreparer(ctx context.Context, accountName, shareName string, quotaGB int) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - "comp": autorest.Encode("query", "properties"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "x-ms-share-quota": quotaGB, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetPropertiesSender sends the SetProperties request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetPropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetPropertiesResponder handles the response to the SetProperties request. The method always -// closes the http.Response Body. -func (client Client) SetPropertiesResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go deleted file mode 100644 index c51d399ca062..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/resource_id.go +++ /dev/null @@ -1,53 +0,0 @@ -package shares - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given File Share -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, shareName string) string { - domain := endpoints.GetFileEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s", domain, shareName) -} - -// GetResourceManagerResourceID returns the Resource Manager specific -// ResourceID for a specific Storage Share -func (client Client) GetResourceManagerResourceID(subscriptionID, resourceGroup, accountName, shareName string) string { - fmtStr := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Storage/storageAccounts/%s/fileServices/default/shares/%s" - return fmt.Sprintf(fmtStr, subscriptionID, resourceGroup, accountName, shareName) -} - -type ResourceID struct { - AccountName string - ShareName string -} - -// ParseResourceID parses the specified Resource ID and returns an object -// which can be used to interact with the Storage Shares SDK -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.file.core.windows.net/Bar - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - shareName := strings.TrimPrefix(uri.Path, "/") - return &ResourceID{ - AccountName: *accountName, - ShareName: shareName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go deleted file mode 100644 index 0ded38b1975a..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_create.go +++ /dev/null @@ -1,115 +0,0 @@ -package shares - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type CreateSnapshotInput struct { - MetaData map[string]string -} - -type CreateSnapshotResult struct { - autorest.Response - - // This header is a DateTime value that uniquely identifies the share snapshot. - // The value of this header may be used in subsequent requests to access the share snapshot. - // This value is opaque. - SnapshotDateTime string -} - -// CreateSnapshot creates a read-only snapshot of the share -// A share can support creation of 200 share snapshots. Attempting to create more than 200 share snapshots fails with 409 (Conflict). -// Attempting to create a share snapshot while a previous Snapshot Share operation is in progress fails with 409 (Conflict). -func (client Client) CreateSnapshot(ctx context.Context, accountName, shareName string, input CreateSnapshotInput) (result CreateSnapshotResult, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "CreateSnapshot", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "CreateSnapshot", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "CreateSnapshot", "`shareName` must be a lower-cased string.") - } - if err := metadata.Validate(input.MetaData); err != nil { - return result, validation.NewError("shares.Client", "CreateSnapshot", fmt.Sprintf("`input.MetaData` is not valid: %s.", err)) - } - - req, err := client.CreateSnapshotPreparer(ctx, accountName, shareName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "CreateSnapshot", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSnapshotSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "CreateSnapshot", resp, "Failure sending request") - return - } - - result, err = client.CreateSnapshotResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "CreateSnapshot", resp, "Failure responding to request") - return - } - - return -} - -// CreateSnapshotPreparer prepares the CreateSnapshot request. -func (client Client) CreateSnapshotPreparer(ctx context.Context, accountName, shareName string, input CreateSnapshotInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "snapshot"), - "restype": autorest.Encode("query", "share"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = metadata.SetIntoHeaders(headers, input.MetaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// CreateSnapshotSender sends the CreateSnapshot request. The method will close the -// http.Response Body if it receives an error. -func (client Client) CreateSnapshotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateSnapshotResponder handles the response to the CreateSnapshot request. The method always -// closes the http.Response Body. -func (client Client) CreateSnapshotResponder(resp *http.Response) (result CreateSnapshotResult, err error) { - result.SnapshotDateTime = resp.Header.Get("x-ms-snapshot") - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go deleted file mode 100644 index 1f5d665cb104..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_delete.go +++ /dev/null @@ -1,94 +0,0 @@ -package shares - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// DeleteSnapshot deletes the specified Snapshot of a Storage Share -func (client Client) DeleteSnapshot(ctx context.Context, accountName, shareName string, shareSnapshot string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "DeleteSnapshot", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "DeleteSnapshot", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "DeleteSnapshot", "`shareName` must be a lower-cased string.") - } - if shareSnapshot == "" { - return result, validation.NewError("shares.Client", "DeleteSnapshot", "`shareSnapshot` cannot be an empty string.") - } - - req, err := client.DeleteSnapshotPreparer(ctx, accountName, shareName, shareSnapshot) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "DeleteSnapshot", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSnapshotSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "DeleteSnapshot", resp, "Failure sending request") - return - } - - result, err = client.DeleteSnapshotResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "DeleteSnapshot", resp, "Failure responding to request") - return - } - - return -} - -// DeleteSnapshotPreparer prepares the DeleteSnapshot request. -func (client Client) DeleteSnapshotPreparer(ctx context.Context, accountName, shareName string, shareSnapshot string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("path", "share"), - "sharesnapshot": autorest.Encode("query", shareSnapshot), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// DeleteSnapshotSender sends the DeleteSnapshot request. The method will close the -// http.Response Body if it receives an error. -func (client Client) DeleteSnapshotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteSnapshotResponder handles the response to the DeleteSnapshot request. The method always -// closes the http.Response Body. -func (client Client) DeleteSnapshotResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go deleted file mode 100644 index 2cf5f16f618e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/snapshot_get.go +++ /dev/null @@ -1,105 +0,0 @@ -package shares - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetSnapshotPropertiesResult struct { - autorest.Response - - MetaData map[string]string -} - -// GetSnapshot gets information about the specified Snapshot of the specified Storage Share -func (client Client) GetSnapshot(ctx context.Context, accountName, shareName, snapshotShare string) (result GetSnapshotPropertiesResult, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "GetSnapshot", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "GetSnapshot", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "GetSnapshot", "`shareName` must be a lower-cased string.") - } - if snapshotShare == "" { - return result, validation.NewError("shares.Client", "GetSnapshot", "`snapshotShare` cannot be an empty string.") - } - - req, err := client.GetSnapshotPreparer(ctx, accountName, shareName, snapshotShare) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetSnapshot", nil, "Failure preparing request") - return - } - - resp, err := client.GetSnapshotSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "GetSnapshot", resp, "Failure sending request") - return - } - - result, err = client.GetSnapshotResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetSnapshot", resp, "Failure responding to request") - return - } - - return -} - -// GetSnapshotPreparer prepares the GetSnapshot request. -func (client Client) GetSnapshotPreparer(ctx context.Context, accountName, shareName, snapshotShare string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - "snapshot": autorest.Encode("query", snapshotShare), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetSnapshotSender sends the GetSnapshot request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetSnapshotSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetSnapshotResponder handles the response to the GetSnapshot request. The method always -// closes the http.Response Body. -func (client Client) GetSnapshotResponder(resp *http.Response) (result GetSnapshotPropertiesResult, err error) { - if resp.Header != nil { - result.MetaData = metadata.ParseFromHeaders(resp.Header) - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go deleted file mode 100644 index 3539eccbcd0e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/stats.go +++ /dev/null @@ -1,100 +0,0 @@ -package shares - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetStatsResult struct { - autorest.Response - - // The approximate size of the data stored on the share. - // Note that this value may not include all recently created or recently resized files. - ShareUsageBytes int64 `xml:"ShareUsageBytes"` -} - -// GetStats returns information about the specified Storage Share -func (client Client) GetStats(ctx context.Context, accountName, shareName string) (result GetStatsResult, err error) { - if accountName == "" { - return result, validation.NewError("shares.Client", "GetStats", "`accountName` cannot be an empty string.") - } - if shareName == "" { - return result, validation.NewError("shares.Client", "GetStats", "`shareName` cannot be an empty string.") - } - if strings.ToLower(shareName) != shareName { - return result, validation.NewError("shares.Client", "GetStats", "`shareName` must be a lower-cased string.") - } - - req, err := client.GetStatsPreparer(ctx, accountName, shareName) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetStats", nil, "Failure preparing request") - return - } - - resp, err := client.GetStatsSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "shares.Client", "GetStats", resp, "Failure sending request") - return - } - - result, err = client.GetStatsResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "shares.Client", "GetStats", resp, "Failure responding to request") - return - } - - return -} - -// GetStatsPreparer prepares the GetStats request. -func (client Client) GetStatsPreparer(ctx context.Context, accountName, shareName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "shareName": autorest.Encode("path", shareName), - } - - queryParameters := map[string]interface{}{ - "restype": autorest.Encode("query", "share"), - "comp": autorest.Encode("query", "stats"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetFileEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{shareName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) GetStatsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetStatsResponder handles the response to the GetStats request. The method always -// closes the http.Response Body. -func (client Client) GetStatsResponder(resp *http.Response) (result GetStatsResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go deleted file mode 100644 index 653693959b6f..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/file/shares/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package shares - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md deleted file mode 100644 index b8b84a3799a8..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/README.md +++ /dev/null @@ -1,43 +0,0 @@ -## Queue Storage Queues SDK for API version 2020-08-04 - -This package allows you to interact with the Queues Queue Storage API - -### Supported Authorizers - -* Azure Active Directory (for the Resource Endpoint `https://storage.azure.com`) -* SharedKeyLite (Blob, File & Queue) - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - queueName := "myqueue" - - storageAuth := autorest.NewSharedKeyLiteAuthorizer(accountName, storageAccountKey) - queuesClient := queues.New() - queuesClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - metadata := map[string]string{ - "hello": "world", - } - if _, err := queuesClient.Create(ctx, accountName, queueName, metadata); err != nil { - return fmt.Errorf("Error creating Queue: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go deleted file mode 100644 index e4c14220b68c..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/api.go +++ /dev/null @@ -1,17 +0,0 @@ -package queues - -import ( - "context" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageQueue interface { - Delete(ctx context.Context, accountName, queueName string) (result autorest.Response, err error) - GetMetaData(ctx context.Context, accountName, queueName string) (result GetMetaDataResult, err error) - SetMetaData(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) - Create(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) - GetResourceID(accountName, queueName string) string - SetServiceProperties(ctx context.Context, accountName string, properties StorageServiceProperties) (result autorest.Response, err error) - GetServiceProperties(ctx context.Context, accountName string) (result StorageServicePropertiesResponse, err error) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go deleted file mode 100644 index 2f8008582b93..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package queues - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Queue Storage Shares. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go deleted file mode 100644 index f18910a88d9e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/create.go +++ /dev/null @@ -1,92 +0,0 @@ -package queues - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -// Create creates the specified Queue within the specified Storage Account -func (client Client) Create(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("queues.Client", "Create", "`accountName` cannot be an empty string.") - } - if queueName == "" { - return result, validation.NewError("queues.Client", "Create", "`queueName` cannot be an empty string.") - } - if strings.ToLower(queueName) != queueName { - return result, validation.NewError("queues.Client", "Create", "`queueName` must be a lower-cased string.") - } - if err := metadata.Validate(metaData); err != nil { - return result, validation.NewError("queues.Client", "Create", fmt.Sprintf("`metadata` is not valid: %s.", err)) - } - - req, err := client.CreatePreparer(ctx, accountName, queueName, metaData) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "queues.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "Create", resp, "Failure responding to request") - return - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName string, queueName string, metaData map[string]string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "queueName": autorest.Encode("path", queueName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = metadata.SetIntoHeaders(headers, metaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{queueName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusCreated), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go deleted file mode 100644 index 5f705959c446..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/delete.go +++ /dev/null @@ -1,85 +0,0 @@ -package queues - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete deletes the specified Queue within the specified Storage Account -func (client Client) Delete(ctx context.Context, accountName, queueName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("queues.Client", "Delete", "`accountName` cannot be an empty string.") - } - if queueName == "" { - return result, validation.NewError("queues.Client", "Delete", "`queueName` cannot be an empty string.") - } - if strings.ToLower(queueName) != queueName { - return result, validation.NewError("queues.Client", "Delete", "`queueName` must be a lower-cased string.") - } - - req, err := client.DeletePreparer(ctx, accountName, queueName) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "queues.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName string, queueName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "queueName": autorest.Encode("path", queueName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{queueName}", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go deleted file mode 100644 index 9c230b613ad3..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_get.go +++ /dev/null @@ -1,101 +0,0 @@ -package queues - -import ( - "context" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -type GetMetaDataResult struct { - autorest.Response - - MetaData map[string]string -} - -// GetMetaData returns the metadata for this Queue -func (client Client) GetMetaData(ctx context.Context, accountName, queueName string) (result GetMetaDataResult, err error) { - if accountName == "" { - return result, validation.NewError("queues.Client", "GetMetaData", "`accountName` cannot be an empty string.") - } - if queueName == "" { - return result, validation.NewError("queues.Client", "GetMetaData", "`queueName` cannot be an empty string.") - } - if strings.ToLower(queueName) != queueName { - return result, validation.NewError("queues.Client", "GetMetaData", "`queueName` must be a lower-cased string.") - } - - req, err := client.GetMetaDataPreparer(ctx, accountName, queueName) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "GetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.GetMetaDataSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "queues.Client", "GetMetaData", resp, "Failure sending request") - return - } - - result, err = client.GetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "GetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// GetMetaDataPreparer prepares the GetMetaData request. -func (client Client) GetMetaDataPreparer(ctx context.Context, accountName, queueName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "queueName": autorest.Encode("path", queueName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{queueName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetMetaDataSender sends the GetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetMetaDataResponder handles the response to the GetMetaData request. The method always -// closes the http.Response Body. -func (client Client) GetMetaDataResponder(resp *http.Response) (result GetMetaDataResult, err error) { - if resp != nil { - result.MetaData = metadata.ParseFromHeaders(resp.Header) - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go deleted file mode 100644 index 51154a5c4334..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/metadata_set.go +++ /dev/null @@ -1,97 +0,0 @@ -package queues - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" - "github.com/tombuildsstuff/giovanni/storage/internal/metadata" -) - -// SetMetaData returns the metadata for this Queue -func (client Client) SetMetaData(ctx context.Context, accountName, queueName string, metaData map[string]string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("queues.Client", "SetMetaData", "`accountName` cannot be an empty string.") - } - if queueName == "" { - return result, validation.NewError("queues.Client", "SetMetaData", "`queueName` cannot be an empty string.") - } - if strings.ToLower(queueName) != queueName { - return result, validation.NewError("queues.Client", "SetMetaData", "`queueName` must be a lower-cased string.") - } - if err := metadata.Validate(metaData); err != nil { - return result, validation.NewError("queues.Client", "SetMetaData", fmt.Sprintf("`metadata` is not valid: %s.", err)) - } - - req, err := client.SetMetaDataPreparer(ctx, accountName, queueName, metaData) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "SetMetaData", nil, "Failure preparing request") - return - } - - resp, err := client.SetMetaDataSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "queues.Client", "SetMetaData", resp, "Failure sending request") - return - } - - result, err = client.SetMetaDataResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "SetMetaData", resp, "Failure responding to request") - return - } - - return -} - -// SetMetaDataPreparer prepares the SetMetaData request. -func (client Client) SetMetaDataPreparer(ctx context.Context, accountName, queueName string, metaData map[string]string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "queueName": autorest.Encode("path", queueName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "metadata"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - headers = metadata.SetIntoHeaders(headers, metaData) - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{queueName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetMetaDataSender sends the SetMetaData request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetMetaDataSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetMetaDataResponder handles the response to the SetMetaData request. The method always -// closes the http.Response Body. -func (client Client) SetMetaDataResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go deleted file mode 100644 index 0afe8b6060cb..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/models.go +++ /dev/null @@ -1,42 +0,0 @@ -package queues - -type StorageServiceProperties struct { - Logging *LoggingConfig `xml:"Logging,omitempty"` - HourMetrics *MetricsConfig `xml:"HourMetrics,omitempty"` - MinuteMetrics *MetricsConfig `xml:"MinuteMetrics,omitempty"` - Cors *Cors `xml:"Cors,omitempty"` -} - -type LoggingConfig struct { - Version string `xml:"Version"` - Delete bool `xml:"Delete"` - Read bool `xml:"Read"` - Write bool `xml:"Write"` - RetentionPolicy RetentionPolicy `xml:"RetentionPolicy"` -} - -type MetricsConfig struct { - Version string `xml:"Version"` - Enabled bool `xml:"Enabled"` - RetentionPolicy RetentionPolicy `xml:"RetentionPolicy"` - - // Element IncludeAPIs is only expected when Metrics is enabled - IncludeAPIs *bool `xml:"IncludeAPIs,omitempty"` -} - -type RetentionPolicy struct { - Enabled bool `xml:"Enabled"` - Days int `xml:"Days"` -} - -type Cors struct { - CorsRule []CorsRule `xml:"CorsRule"` -} - -type CorsRule struct { - AllowedOrigins string `xml:"AllowedOrigins"` - AllowedMethods string `xml:"AllowedMethods"` - AllowedHeaders string `xml:"AllowedHeaders` - ExposedHeaders string `xml:"ExposedHeaders"` - MaxAgeInSeconds int `xml:"MaxAgeInSeconds"` -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go deleted file mode 100644 index a0e51ad34354..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_get.go +++ /dev/null @@ -1,86 +0,0 @@ -package queues - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type StorageServicePropertiesResponse struct { - StorageServiceProperties - autorest.Response -} - -// SetServiceProperties gets the properties for this queue -func (client Client) GetServiceProperties(ctx context.Context, accountName string) (result StorageServicePropertiesResponse, err error) { - if accountName == "" { - return result, validation.NewError("queues.Client", "GetServiceProperties", "`accountName` cannot be an empty string.") - } - - req, err := client.GetServicePropertiesPreparer(ctx, accountName) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "GetServiceProperties", nil, "Failure preparing request") - return - } - - resp, err := client.GetServicePropertiesSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "queues.Client", "GetServiceProperties", resp, "Failure sending request") - return - } - - result, err = client.GetServicePropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "GetServiceProperties", resp, "Failure responding to request") - return - } - - return -} - -// GetServicePropertiesPreparer prepares the GetServiceProperties request. -func (client Client) GetServicePropertiesPreparer(ctx context.Context, accountName string) (*http.Request, error) { - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "properties"), - "restype": autorest.Encode("path", "service"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), - autorest.WithPath("/"), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetServicePropertiesSender sends the GetServiceProperties request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetServicePropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetServicePropertiesResponder handles the response to the GetServiceProperties request. The method always -// closes the http.Response Body. -func (client Client) GetServicePropertiesResponder(resp *http.Response) (result StorageServicePropertiesResponse, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go deleted file mode 100644 index 33dd40b3da1f..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/properties_set.go +++ /dev/null @@ -1,81 +0,0 @@ -package queues - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// SetServiceProperties sets the properties for this queue -func (client Client) SetServiceProperties(ctx context.Context, accountName string, properties StorageServiceProperties) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("queues.Client", "SetServiceProperties", "`accountName` cannot be an empty string.") - } - - req, err := client.SetServicePropertiesPreparer(ctx, accountName, properties) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "SetServiceProperties", nil, "Failure preparing request") - return - } - - resp, err := client.SetServicePropertiesSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "queues.Client", "SetServiceProperties", resp, "Failure sending request") - return - } - - result, err = client.SetServicePropertiesResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "queues.Client", "SetServiceProperties", resp, "Failure responding to request") - return - } - - return -} - -// SetServicePropertiesPreparer prepares the SetServiceProperties request. -func (client Client) SetServicePropertiesPreparer(ctx context.Context, accountName string, properties StorageServiceProperties) (*http.Request, error) { - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("path", "properties"), - "restype": autorest.Encode("path", "service"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetQueueEndpoint(client.BaseURI, accountName)), - autorest.WithPath("/"), - autorest.WithQueryParameters(queryParameters), - autorest.WithXML(properties), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetServicePropertiesSender sends the SetServiceProperties request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetServicePropertiesSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetServicePropertiesResponder handles the response to the SetServiceProperties request. The method always -// closes the http.Response Body. -func (client Client) SetServicePropertiesResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusAccepted), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go deleted file mode 100644 index 912923abca0d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/resource_id.go +++ /dev/null @@ -1,46 +0,0 @@ -package queues - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Queue -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, queueName string) string { - domain := endpoints.GetQueueEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s", domain, queueName) -} - -type ResourceID struct { - AccountName string - QueueName string -} - -// ParseResourceID parses the Resource ID and returns an Object which -// can be used to interact with a Queue within a Storage Account -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.queue.core.windows.net/Bar - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - queueName := strings.TrimPrefix(uri.Path, "/") - return &ResourceID{ - AccountName: *accountName, - QueueName: queueName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go deleted file mode 100644 index 9d3e68949fec..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/queue/queues/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package queues - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md deleted file mode 100644 index e59b5a28335a..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/README.md +++ /dev/null @@ -1,48 +0,0 @@ -## Table Storage Entities SDK for API version 2020-08-04 - -This package allows you to interact with the Entities Table Storage API - -### Supported Authorizers - -* SharedKeyLite (Table) - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - tableName := "mytable" - - storageAuth := autorest.NewSharedKeyLiteTableAuthorizer(accountName, storageAccountKey) - entitiesClient := entities.New() - entitiesClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - input := entities.InsertEntityInput{ - PartitionKey: "abc", - RowKey: "123", - MetaDataLevel: entities.NoMetaData, - Entity: map[string]interface{}{ - "title": "Don't Kill My Vibe", - "artist": "Sigrid", - }, - } - if _, err := entitiesClient.Insert(ctx, accountName, tableName, input); err != nil { - return fmt.Errorf("Error creating Entity: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go deleted file mode 100644 index d4d20a723457..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/api.go +++ /dev/null @@ -1,17 +0,0 @@ -package entities - -import ( - "context" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageTableEntity interface { - Delete(ctx context.Context, accountName, tableName string, input DeleteEntityInput) (result autorest.Response, err error) - Insert(ctx context.Context, accountName, tableName string, input InsertEntityInput) (result autorest.Response, err error) - InsertOrReplace(ctx context.Context, accountName, tableName string, input InsertOrReplaceEntityInput) (result autorest.Response, err error) - InsertOrMerge(ctx context.Context, accountName, tableName string, input InsertOrMergeEntityInput) (result autorest.Response, err error) - Query(ctx context.Context, accountName, tableName string, input QueryEntitiesInput) (result QueryEntitiesResult, err error) - Get(ctx context.Context, accountName, tableName string, input GetEntityInput) (result GetEntityResult, err error) - GetResourceID(accountName, tableName, partitionKey, rowKey string) string -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go deleted file mode 100644 index 17e9d759fb9e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package entities - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Table Storage Shares. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go deleted file mode 100644 index 83e9188e5e9e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/delete.go +++ /dev/null @@ -1,99 +0,0 @@ -package entities - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type DeleteEntityInput struct { - // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. - // Together, these properties form the primary key and must be unique within the table. - // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. - // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, - // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. - RowKey string - PartitionKey string -} - -// Delete deletes an existing entity in a table. -func (client Client) Delete(ctx context.Context, accountName, tableName string, input DeleteEntityInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("entities.Client", "Delete", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("entities.Client", "Delete", "`tableName` cannot be an empty string.") - } - if input.PartitionKey == "" { - return result, validation.NewError("entities.Client", "Delete", "`input.PartitionKey` cannot be an empty string.") - } - if input.RowKey == "" { - return result, validation.NewError("entities.Client", "Delete", "`input.RowKey` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, tableName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "entities.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName, tableName string, input DeleteEntityInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - "partitionKey": autorest.Encode("path", input.PartitionKey), - "rowKey": autorest.Encode("path", input.RowKey), - } - - headers := map[string]interface{}{ - // TODO: support for eTags - "If-Match": "*", - } - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}', RowKey='{rowKey}')", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go deleted file mode 100644 index bdb40180b54d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/get.go +++ /dev/null @@ -1,108 +0,0 @@ -package entities - -import ( - "context" - "fmt" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetEntityInput struct { - PartitionKey string - RowKey string - - // The Level of MetaData which should be returned - MetaDataLevel MetaDataLevel -} - -type GetEntityResult struct { - autorest.Response - - Entity map[string]interface{} -} - -// Get queries entities in a table and includes the $filter and $select options. -func (client Client) Get(ctx context.Context, accountName, tableName string, input GetEntityInput) (result GetEntityResult, err error) { - if accountName == "" { - return result, validation.NewError("entities.Client", "Get", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("entities.Client", "Get", "`tableName` cannot be an empty string.") - } - if input.PartitionKey == "" { - return result, validation.NewError("entities.Client", "Get", "`input.PartitionKey` cannot be an empty string.") - } - if input.RowKey == "" { - return result, validation.NewError("entities.Client", "Get", "`input.RowKey` cannot be an empty string.") - } - - req, err := client.GetPreparer(ctx, accountName, tableName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Get", nil, "Failure preparing request") - return - } - - resp, err := client.GetSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "entities.Client", "Get", resp, "Failure sending request") - return - } - - result, err = client.GetResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Get", resp, "Failure responding to request") - return - } - - return -} - -// GetPreparer prepares the Get request. -func (client Client) GetPreparer(ctx context.Context, accountName, tableName string, input GetEntityInput) (*http.Request, error) { - - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - "partitionKey": autorest.Encode("path", input.PartitionKey), - "rowKey": autorest.Encode("path", input.RowKey), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "Accept": fmt.Sprintf("application/json;odata=%s", input.MetaDataLevel), - "DataServiceVersion": "3.0;NetFx", - "MaxDataServiceVersion": "3.0;NetFx", - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}',RowKey='{rowKey}')", pathParameters), - autorest.WithHeaders(headers)) - 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 Client) GetSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetResponder handles the response to the Get request. The method always -// closes the http.Response Body. -func (client Client) GetResponder(resp *http.Response) (result GetEntityResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result.Entity), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go deleted file mode 100644 index 92b05cef5499..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert.go +++ /dev/null @@ -1,112 +0,0 @@ -package entities - -import ( - "context" - "fmt" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type InsertEntityInput struct { - // The level of MetaData provided for this Entity - MetaDataLevel MetaDataLevel - - // The Entity which should be inserted, by default all values are strings - // To explicitly type a property, specify the appropriate OData data type by setting - // the m:type attribute within the property definition - Entity map[string]interface{} - - // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. - // Together, these properties form the primary key and must be unique within the table. - // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. - // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, - // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. - RowKey string - PartitionKey string -} - -// Insert inserts a new entity into a table. -func (client Client) Insert(ctx context.Context, accountName, tableName string, input InsertEntityInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("entities.Client", "Insert", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("entities.Client", "Insert", "`tableName` cannot be an empty string.") - } - if input.PartitionKey == "" { - return result, validation.NewError("entities.Client", "Insert", "`input.PartitionKey` cannot be an empty string.") - } - if input.RowKey == "" { - return result, validation.NewError("entities.Client", "Insert", "`input.RowKey` cannot be an empty string.") - } - - req, err := client.InsertPreparer(ctx, accountName, tableName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Insert", nil, "Failure preparing request") - return - } - - resp, err := client.InsertSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "entities.Client", "Insert", resp, "Failure sending request") - return - } - - result, err = client.InsertResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Insert", resp, "Failure responding to request") - return - } - - return -} - -// InsertPreparer prepares the Insert request. -func (client Client) InsertPreparer(ctx context.Context, accountName, tableName string, input InsertEntityInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "Accept": fmt.Sprintf("application/json;odata=%s", input.MetaDataLevel), - "Prefer": "return-no-content", - } - - input.Entity["PartitionKey"] = input.PartitionKey - input.Entity["RowKey"] = input.RowKey - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/json"), - autorest.AsPost(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}", pathParameters), - autorest.WithJSON(input.Entity), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// InsertSender sends the Insert request. The method will close the -// http.Response Body if it receives an error. -func (client Client) InsertSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// InsertResponder handles the response to the Insert request. The method always -// closes the http.Response Body. -func (client Client) InsertResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go deleted file mode 100644 index 1fb4ed3df164..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_merge.go +++ /dev/null @@ -1,108 +0,0 @@ -package entities - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type InsertOrMergeEntityInput struct { - // The Entity which should be inserted, by default all values are strings - // To explicitly type a property, specify the appropriate OData data type by setting - // the m:type attribute within the property definition - Entity map[string]interface{} - - // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. - // Together, these properties form the primary key and must be unique within the table. - // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. - // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, - // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. - RowKey string - PartitionKey string -} - -// InsertOrMerge updates an existing entity or inserts a new entity if it does not exist in the table. -// Because this operation can insert or update an entity, it is also known as an upsert operation. -func (client Client) InsertOrMerge(ctx context.Context, accountName, tableName string, input InsertOrMergeEntityInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("entities.Client", "InsertOrMerge", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("entities.Client", "InsertOrMerge", "`tableName` cannot be an empty string.") - } - if input.PartitionKey == "" { - return result, validation.NewError("entities.Client", "InsertOrMerge", "`input.PartitionKey` cannot be an empty string.") - } - if input.RowKey == "" { - return result, validation.NewError("entities.Client", "InsertOrMerge", "`input.RowKey` cannot be an empty string.") - } - - req, err := client.InsertOrMergePreparer(ctx, accountName, tableName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrMerge", nil, "Failure preparing request") - return - } - - resp, err := client.InsertOrMergeSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrMerge", resp, "Failure sending request") - return - } - - result, err = client.InsertOrMergeResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrMerge", resp, "Failure responding to request") - return - } - - return -} - -// InsertOrMergePreparer prepares the InsertOrMerge request. -func (client Client) InsertOrMergePreparer(ctx context.Context, accountName, tableName string, input InsertOrMergeEntityInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - "partitionKey": autorest.Encode("path", input.PartitionKey), - "rowKey": autorest.Encode("path", input.RowKey), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "Accept": "application/json", - "Prefer": "return-no-content", - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/json"), - autorest.AsMerge(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}', RowKey='{rowKey}')", pathParameters), - autorest.WithJSON(input.Entity), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// InsertOrMergeSender sends the InsertOrMerge request. The method will close the -// http.Response Body if it receives an error. -func (client Client) InsertOrMergeSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// InsertOrMergeResponder handles the response to the InsertOrMerge request. The method always -// closes the http.Response Body. -func (client Client) InsertOrMergeResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go deleted file mode 100644 index 036ba5de5fe7..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/insert_or_replace.go +++ /dev/null @@ -1,108 +0,0 @@ -package entities - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type InsertOrReplaceEntityInput struct { - // The Entity which should be inserted, by default all values are strings - // To explicitly type a property, specify the appropriate OData data type by setting - // the m:type attribute within the property definition - Entity map[string]interface{} - - // When inserting an entity into a table, you must specify values for the PartitionKey and RowKey system properties. - // Together, these properties form the primary key and must be unique within the table. - // Both the PartitionKey and RowKey values must be string values; each key value may be up to 64 KB in size. - // If you are using an integer value for the key value, you should convert the integer to a fixed-width string, - // because they are canonically sorted. For example, you should convert the value 1 to 0000001 to ensure proper sorting. - RowKey string - PartitionKey string -} - -// InsertOrReplace replaces an existing entity or inserts a new entity if it does not exist in the table. -// Because this operation can insert or update an entity, it is also known as an upsert operation. -func (client Client) InsertOrReplace(ctx context.Context, accountName, tableName string, input InsertOrReplaceEntityInput) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("entities.Client", "InsertOrReplace", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("entities.Client", "InsertOrReplace", "`tableName` cannot be an empty string.") - } - if input.PartitionKey == "" { - return result, validation.NewError("entities.Client", "InsertOrReplace", "`input.PartitionKey` cannot be an empty string.") - } - if input.RowKey == "" { - return result, validation.NewError("entities.Client", "InsertOrReplace", "`input.RowKey` cannot be an empty string.") - } - - req, err := client.InsertOrReplacePreparer(ctx, accountName, tableName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrReplace", nil, "Failure preparing request") - return - } - - resp, err := client.InsertOrReplaceSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrReplace", resp, "Failure sending request") - return - } - - result, err = client.InsertOrReplaceResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "InsertOrReplace", resp, "Failure responding to request") - return - } - - return -} - -// InsertOrReplacePreparer prepares the InsertOrReplace request. -func (client Client) InsertOrReplacePreparer(ctx context.Context, accountName, tableName string, input InsertOrReplaceEntityInput) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - "partitionKey": autorest.Encode("path", input.PartitionKey), - "rowKey": autorest.Encode("path", input.RowKey), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "Accept": "application/json", - "Prefer": "return-no-content", - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/json"), - autorest.AsMerge(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}(PartitionKey='{partitionKey}', RowKey='{rowKey}')", pathParameters), - autorest.WithJSON(input.Entity), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// InsertOrReplaceSender sends the InsertOrReplace request. The method will close the -// http.Response Body if it receives an error. -func (client Client) InsertOrReplaceSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// InsertOrReplaceResponder handles the response to the InsertOrReplace request. The method always -// closes the http.Response Body. -func (client Client) InsertOrReplaceResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go deleted file mode 100644 index e3c6cccb59ce..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/models.go +++ /dev/null @@ -1,9 +0,0 @@ -package entities - -type MetaDataLevel string - -var ( - NoMetaData MetaDataLevel = "nometadata" - MinimalMetaData MetaDataLevel = "minimalmetadata" - FullMetaData MetaDataLevel = "fullmetadata" -) diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go deleted file mode 100644 index c1ba3706be7d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/query.go +++ /dev/null @@ -1,162 +0,0 @@ -package entities - -import ( - "context" - "fmt" - "net/http" - "strings" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type QueryEntitiesInput struct { - // An optional OData filter - Filter *string - - // An optional comma-separated - PropertyNamesToSelect *[]string - - // An optional OData top - Top *int - - PartitionKey string - RowKey string - - // The Level of MetaData which should be returned - MetaDataLevel MetaDataLevel - - // The Next Partition Key used to load data from a previous point - NextPartitionKey *string - - // The Next Row Key used to load data from a previous point - NextRowKey *string -} - -type QueryEntitiesResult struct { - autorest.Response - - NextPartitionKey string - NextRowKey string - - MetaData string `json:"odata.metadata,omitempty"` - Entities []map[string]interface{} `json:"value"` -} - -// Query queries entities in a table and includes the $filter and $select options. -func (client Client) Query(ctx context.Context, accountName, tableName string, input QueryEntitiesInput) (result QueryEntitiesResult, err error) { - if accountName == "" { - return result, validation.NewError("entities.Client", "Query", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("entities.Client", "Query", "`tableName` cannot be an empty string.") - } - - req, err := client.QueryPreparer(ctx, accountName, tableName, input) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Query", nil, "Failure preparing request") - return - } - - resp, err := client.QuerySender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "entities.Client", "Query", resp, "Failure sending request") - return - } - - result, err = client.QueryResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "entities.Client", "Query", resp, "Failure responding to request") - return - } - - return -} - -// QueryPreparer prepares the Query request. -func (client Client) QueryPreparer(ctx context.Context, accountName, tableName string, input QueryEntitiesInput) (*http.Request, error) { - - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - "additionalParameters": "", - } - - //PartitionKey='',RowKey='' - additionalParams := make([]string, 0) - if input.PartitionKey != "" { - additionalParams = append(additionalParams, fmt.Sprintf("PartitionKey='%s'", input.PartitionKey)) - } - if input.RowKey != "" { - additionalParams = append(additionalParams, fmt.Sprintf("RowKey='%s'", input.RowKey)) - } - if len(additionalParams) > 0 { - pathParameters["additionalParameters"] = autorest.Encode("path", strings.Join(additionalParams, ",")) - } - - queryParameters := map[string]interface{}{} - - if input.Filter != nil { - queryParameters["$filter"] = autorest.Encode("query", *input.Filter) - } - - if input.PropertyNamesToSelect != nil { - queryParameters["$select"] = autorest.Encode("query", strings.Join(*input.PropertyNamesToSelect, ",")) - } - - if input.Top != nil { - queryParameters["$top"] = autorest.Encode("query", *input.Top) - } - - if input.NextPartitionKey != nil { - queryParameters["NextPartitionKey"] = *input.NextPartitionKey - } - - if input.NextRowKey != nil { - queryParameters["NextRowKey"] = *input.NextRowKey - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "Accept": fmt.Sprintf("application/json;odata=%s", input.MetaDataLevel), - "DataServiceVersion": "3.0;NetFx", - "MaxDataServiceVersion": "3.0;NetFx", - } - - // GET /myaccount/Customers()?$filter=(Rating%20ge%203)%20and%20(Rating%20le%206)&$select=PartitionKey,RowKey,Address,CustomerSince - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}({additionalParameters})", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - 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 Client) QuerySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// QueryResponder handles the response to the Query request. The method always -// closes the http.Response Body. -func (client Client) QueryResponder(resp *http.Response) (result QueryEntitiesResult, err error) { - if resp != nil && resp.Header != nil { - result.NextPartitionKey = resp.Header.Get("x-ms-continuation-NextPartitionKey") - result.NextRowKey = resp.Header.Get("x-ms-continuation-NextRowKey") - } - - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go deleted file mode 100644 index 249671dc91bf..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/resource_id.go +++ /dev/null @@ -1,91 +0,0 @@ -package entities - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Entity -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, tableName, partitionKey, rowKey string) string { - domain := endpoints.GetTableEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/%s(PartitionKey='%s',RowKey='%s')", domain, tableName, partitionKey, rowKey) -} - -type ResourceID struct { - AccountName string - TableName string - PartitionKey string - RowKey string -} - -// ParseResourceID parses the specified Resource ID and returns an object which -// can be used to look up the specified Entity within the specified Table -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://account1.table.core.chinacloudapi.cn/table1(PartitionKey='partition1',RowKey='row1') - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - // assume there a `Table('')` - path := strings.TrimPrefix(uri.Path, "/") - if !strings.Contains(uri.Path, "(") || !strings.HasSuffix(uri.Path, ")") { - return nil, fmt.Errorf("Expected the Table Name to be in the format `tables(PartitionKey='',RowKey='')` but got %q", path) - } - - // NOTE: honestly this could probably be a RegEx, but this seemed like the simplest way to - // allow these two fields to be specified in either order - indexOfBracket := strings.IndexByte(path, '(') - tableName := path[0:indexOfBracket] - - // trim off the brackets - temp := strings.TrimPrefix(path, fmt.Sprintf("%s(", tableName)) - temp = strings.TrimSuffix(temp, ")") - - dictionary := strings.Split(temp, ",") - partitionKey := "" - rowKey := "" - for _, v := range dictionary { - split := strings.Split(v, "=") - if len(split) != 2 { - return nil, fmt.Errorf("Expected 2 segments but got %d for %q", len(split), v) - } - - key := split[0] - value := strings.TrimSuffix(strings.TrimPrefix(split[1], "'"), "'") - if strings.EqualFold(key, "PartitionKey") { - partitionKey = value - } else if strings.EqualFold(key, "RowKey") { - rowKey = value - } else { - return nil, fmt.Errorf("Unexpected Key %q", key) - } - } - - if partitionKey == "" { - return nil, fmt.Errorf("Expected a PartitionKey but didn't get one") - } - if rowKey == "" { - return nil, fmt.Errorf("Expected a RowKey but didn't get one") - } - - return &ResourceID{ - AccountName: *accountName, - TableName: tableName, - PartitionKey: partitionKey, - RowKey: rowKey, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go deleted file mode 100644 index 6270953c7923..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/entities/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package entities - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md deleted file mode 100644 index 40ec34959a79..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/README.md +++ /dev/null @@ -1,39 +0,0 @@ -## Table Storage Tables SDK for API version 2020-08-04 - -This package allows you to interact with the Tables Table Storage API - -### Supported Authorizers - -* SharedKeyLite (Table) - -### Example Usage - -```go -package main - -import ( - "context" - "fmt" - "time" - - "github.com/Azure/go-autorest/autorest" - "github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables" -) - -func Example() error { - accountName := "storageaccount1" - storageAccountKey := "ABC123...." - tableName := "mytable" - - storageAuth := autorest.NewSharedKeyLiteTableAuthorizer(accountName, storageAccountKey) - tablesClient := tables.New() - tablesClient.Client.Authorizer = storageAuth - - ctx := context.TODO() - if _, err := tablesClient.Insert(ctx, accountName, tableName); err != nil { - return fmt.Errorf("Error creating Table: %s", err) - } - - return nil -} -``` \ No newline at end of file diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go deleted file mode 100644 index 0ef00006530f..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_get.go +++ /dev/null @@ -1,93 +0,0 @@ -package tables - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetACLResult struct { - autorest.Response - - SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` -} - -// GetACL returns the Access Control List for the specified Table -func (client Client) GetACL(ctx context.Context, accountName, tableName string) (result GetACLResult, err error) { - if accountName == "" { - return result, validation.NewError("tables.Client", "GetACL", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("tables.Client", "GetACL", "`tableName` cannot be an empty string.") - } - - req, err := client.GetACLPreparer(ctx, accountName, tableName) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "GetACL", nil, "Failure preparing request") - return - } - - resp, err := client.GetACLSender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "tables.Client", "GetACL", resp, "Failure sending request") - return - } - - result, err = client.GetACLResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "GetACL", resp, "Failure responding to request") - return - } - - return -} - -// GetACLPreparer prepares the GetACL request. -func (client Client) GetACLPreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "acl"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// GetACLSender sends the GetACL request. The method will close the -// http.Response Body if it receives an error. -func (client Client) GetACLSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// GetACLResponder handles the response to the GetACL request. The method always -// closes the http.Response Body. -func (client Client) GetACLResponder(resp *http.Response) (result GetACLResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingXML(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go deleted file mode 100644 index c26bffc834d1..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/acl_set.go +++ /dev/null @@ -1,98 +0,0 @@ -package tables - -import ( - "context" - "encoding/xml" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type setAcl struct { - SignedIdentifiers []SignedIdentifier `xml:"SignedIdentifier"` - - XMLName xml.Name `xml:"SignedIdentifiers"` -} - -// SetACL sets the specified Access Control List for the specified Table -func (client Client) SetACL(ctx context.Context, accountName, tableName string, acls []SignedIdentifier) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("tables.Client", "SetACL", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("tables.Client", "SetACL", "`tableName` cannot be an empty string.") - } - - req, err := client.SetACLPreparer(ctx, accountName, tableName, acls) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "SetACL", nil, "Failure preparing request") - return - } - - resp, err := client.SetACLSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "tables.Client", "SetACL", resp, "Failure sending request") - return - } - - result, err = client.SetACLResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "SetACL", resp, "Failure responding to request") - return - } - - return -} - -// SetACLPreparer prepares the SetACL request. -func (client Client) SetACLPreparer(ctx context.Context, accountName, tableName string, acls []SignedIdentifier) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - } - - queryParameters := map[string]interface{}{ - "comp": autorest.Encode("query", "acl"), - } - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - } - - input := setAcl{ - SignedIdentifiers: acls, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/xml; charset=utf-8"), - autorest.AsPut(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/{tableName}", pathParameters), - autorest.WithQueryParameters(queryParameters), - autorest.WithHeaders(headers), - autorest.WithXML(&input)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// SetACLSender sends the SetACL request. The method will close the -// http.Response Body if it receives an error. -func (client Client) SetACLSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// SetACLResponder handles the response to the SetACL request. The method always -// closes the http.Response Body. -func (client Client) SetACLResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go deleted file mode 100644 index d869819ff21e..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/api.go +++ /dev/null @@ -1,17 +0,0 @@ -package tables - -import ( - "context" - - "github.com/Azure/go-autorest/autorest" -) - -type StorageTable interface { - Delete(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) - Exists(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) - GetACL(ctx context.Context, accountName, tableName string) (result GetACLResult, err error) - Create(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) - GetResourceID(accountName, tableName string) string - Query(ctx context.Context, accountName string, metaDataLevel MetaDataLevel) (result GetResult, err error) - SetACL(ctx context.Context, accountName, tableName string, acls []SignedIdentifier) (result autorest.Response, err error) -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go deleted file mode 100644 index 56724b9202c9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/client.go +++ /dev/null @@ -1,25 +0,0 @@ -package tables - -import ( - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" -) - -// Client is the base client for Table Storage Shares. -type Client struct { - autorest.Client - BaseURI string -} - -// New creates an instance of the Client client. -func New() Client { - return NewWithEnvironment(azure.PublicCloud) -} - -// NewWithEnvironment creates an instance of the Client client. -func NewWithEnvironment(environment azure.Environment) Client { - return Client{ - Client: autorest.NewClientWithUserAgent(UserAgent()), - BaseURI: environment.StorageEndpointSuffix, - } -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go deleted file mode 100644 index 561f57460daf..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/create.go +++ /dev/null @@ -1,90 +0,0 @@ -package tables - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type createTableRequest struct { - TableName string `json:"TableName"` -} - -// Create creates a new table in the storage account. -func (client Client) Create(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("tables.Client", "Create", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("tables.Client", "Create", "`tableName` cannot be an empty string.") - } - - req, err := client.CreatePreparer(ctx, accountName, tableName) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Create", nil, "Failure preparing request") - return - } - - resp, err := client.CreateSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "tables.Client", "Create", resp, "Failure sending request") - return - } - - result, err = client.CreateResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Create", resp, "Failure responding to request") - return - } - - return -} - -// CreatePreparer prepares the Create request. -func (client Client) CreatePreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - // NOTE: we could support returning metadata here, but it doesn't appear to be directly useful - // vs making a request using the Get methods as-necessary? - "Accept": "application/json;odata=nometadata", - "Prefer": "return-no-content", - } - - body := createTableRequest{ - TableName: tableName, - } - - preparer := autorest.CreatePreparer( - autorest.AsContentType("application/json"), - autorest.AsPost(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPath("/Tables"), - autorest.WithJSON(body), - autorest.WithHeaders(headers)) - 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 Client) CreateSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// CreateResponder handles the response to the Create request. The method always -// closes the http.Response Body. -func (client Client) CreateResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go deleted file mode 100644 index 5b5ec86d9ca9..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/delete.go +++ /dev/null @@ -1,79 +0,0 @@ -package tables - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Delete deletes the specified table and any data it contains. -func (client Client) Delete(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("tables.Client", "Delete", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("tables.Client", "Delete", "`tableName` cannot be an empty string.") - } - - req, err := client.DeletePreparer(ctx, accountName, tableName) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Delete", nil, "Failure preparing request") - return - } - - resp, err := client.DeleteSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "tables.Client", "Delete", resp, "Failure sending request") - return - } - - result, err = client.DeleteResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Delete", resp, "Failure responding to request") - return - } - - return -} - -// DeletePreparer prepares the Delete request. -func (client Client) DeletePreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - } - - // NOTE: whilst the API documentation says that API Version is Optional - // apparently specifying it causes an "invalid content type" to always be returned - // as such we omit it here :shrug: - - preparer := autorest.CreatePreparer( - autorest.AsDelete(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/Tables('{tableName}')", pathParameters)) - 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 Client) DeleteSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// DeleteResponder handles the response to the Delete request. The method always -// closes the http.Response Body. -func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusNoContent), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go deleted file mode 100644 index b3a271853d82..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/exists.go +++ /dev/null @@ -1,80 +0,0 @@ -package tables - -import ( - "context" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// Exists checks that the specified table exists -func (client Client) Exists(ctx context.Context, accountName, tableName string) (result autorest.Response, err error) { - if accountName == "" { - return result, validation.NewError("tables.Client", "Exists", "`accountName` cannot be an empty string.") - } - if tableName == "" { - return result, validation.NewError("tables.Client", "Exists", "`tableName` cannot be an empty string.") - } - - req, err := client.ExistsPreparer(ctx, accountName, tableName) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Exists", nil, "Failure preparing request") - return - } - - resp, err := client.ExistsSender(req) - if err != nil { - result = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "tables.Client", "Exists", resp, "Failure sending request") - return - } - - result, err = client.ExistsResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Exists", resp, "Failure responding to request") - return - } - - return -} - -// ExistsPreparer prepares the Exists request. -func (client Client) ExistsPreparer(ctx context.Context, accountName, tableName string) (*http.Request, error) { - pathParameters := map[string]interface{}{ - "tableName": autorest.Encode("path", tableName), - } - - // NOTE: whilst the API documentation says that API Version is Optional - // apparently specifying it causes an "invalid content type" to always be returned - // as such we omit it here :shrug: - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.AsContentType("application/xml"), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPathParameters("/Tables('{tableName}')", pathParameters)) - return preparer.Prepare((&http.Request{}).WithContext(ctx)) -} - -// ExistsSender sends the Exists request. The method will close the -// http.Response Body if it receives an error. -func (client Client) ExistsSender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// ExistsResponder handles the response to the Exists request. The method always -// closes the http.Response Body. -func (client Client) ExistsResponder(resp *http.Response) (result autorest.Response, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByClosing()) - result = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go deleted file mode 100644 index d7c382a53959..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/models.go +++ /dev/null @@ -1,29 +0,0 @@ -package tables - -type MetaDataLevel string - -var ( - NoMetaData MetaDataLevel = "nometadata" - MinimalMetaData MetaDataLevel = "minimalmetadata" - FullMetaData MetaDataLevel = "fullmetadata" -) - -type GetResultItem struct { - TableName string `json:"TableName"` - - // Optional, depending on the MetaData Level - ODataType string `json:"odata.type,omitempty"` - ODataID string `json:"odata.id,omitEmpty"` - ODataEditLink string `json:"odata.editLink,omitEmpty"` -} - -type SignedIdentifier struct { - Id string `xml:"Id"` - AccessPolicy AccessPolicy `xml:"AccessPolicy"` -} - -type AccessPolicy struct { - Start string `xml:"Start"` - Expiry string `xml:"Expiry"` - Permission string `xml:"Permission"` -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go deleted file mode 100644 index 475370f0cbd5..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/query.go +++ /dev/null @@ -1,87 +0,0 @@ -package tables - -import ( - "context" - "fmt" - "net/http" - - "github.com/Azure/go-autorest/autorest" - "github.com/Azure/go-autorest/autorest/azure" - "github.com/Azure/go-autorest/autorest/validation" - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -type GetResult struct { - autorest.Response - - MetaData string `json:"odata.metadata,omitempty"` - Tables []GetResultItem `json:"value"` -} - -// Query returns a list of tables under the specified account. -func (client Client) Query(ctx context.Context, accountName string, metaDataLevel MetaDataLevel) (result GetResult, err error) { - if accountName == "" { - return result, validation.NewError("tables.Client", "Query", "`accountName` cannot be an empty string.") - } - - req, err := client.QueryPreparer(ctx, accountName, metaDataLevel) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Query", nil, "Failure preparing request") - return - } - - resp, err := client.QuerySender(req) - if err != nil { - result.Response = autorest.Response{Response: resp} - err = autorest.NewErrorWithError(err, "tables.Client", "Query", resp, "Failure sending request") - return - } - - result, err = client.QueryResponder(resp) - if err != nil { - err = autorest.NewErrorWithError(err, "tables.Client", "Query", resp, "Failure responding to request") - return - } - - return -} - -// QueryPreparer prepares the Query request. -func (client Client) QueryPreparer(ctx context.Context, accountName string, metaDataLevel MetaDataLevel) (*http.Request, error) { - // NOTE: whilst this supports ContinuationTokens and 'Top' - // it appears that 'Skip' returns a '501 Not Implemented' - // as such, we intentionally don't support those right now - - headers := map[string]interface{}{ - "x-ms-version": APIVersion, - "Accept": fmt.Sprintf("application/json;odata=%s", metaDataLevel), - } - - preparer := autorest.CreatePreparer( - autorest.AsGet(), - autorest.WithBaseURL(endpoints.GetTableEndpoint(client.BaseURI, accountName)), - autorest.WithPath("/Tables"), - autorest.WithHeaders(headers)) - 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 Client) QuerySender(req *http.Request) (*http.Response, error) { - return autorest.SendWithSender(client, req, - azure.DoRetryWithRegistration(client.Client)) -} - -// QueryResponder handles the response to the Query request. The method always -// closes the http.Response Body. -func (client Client) QueryResponder(resp *http.Response) (result GetResult, err error) { - err = autorest.Respond( - resp, - client.ByInspecting(), - azure.WithErrorUnlessStatusCode(http.StatusOK), - autorest.ByUnmarshallingJSON(&result), - autorest.ByClosing()) - result.Response = autorest.Response{Response: resp} - - return -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go deleted file mode 100644 index 4ceae10150e0..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/resource_id.go +++ /dev/null @@ -1,54 +0,0 @@ -package tables - -import ( - "fmt" - "net/url" - "strings" - - "github.com/tombuildsstuff/giovanni/storage/internal/endpoints" -) - -// GetResourceID returns the Resource ID for the given Table -// This can be useful when, for example, you're using this as a unique identifier -func (client Client) GetResourceID(accountName, tableName string) string { - domain := endpoints.GetTableEndpoint(client.BaseURI, accountName) - return fmt.Sprintf("%s/Tables('%s')", domain, tableName) -} - -type ResourceID struct { - AccountName string - TableName string -} - -// ParseResourceID parses the Resource ID and returns an object which -// can be used to interact with the Table within the specified Storage Account -func ParseResourceID(id string) (*ResourceID, error) { - // example: https://foo.table.core.windows.net/Table('foo') - if id == "" { - return nil, fmt.Errorf("`id` was empty") - } - - uri, err := url.Parse(id) - if err != nil { - return nil, fmt.Errorf("Error parsing ID as a URL: %s", err) - } - - accountName, err := endpoints.GetAccountNameFromEndpoint(uri.Host) - if err != nil { - return nil, fmt.Errorf("Error parsing Account Name: %s", err) - } - - // assume there a `Table('')` - path := strings.TrimPrefix(uri.Path, "/") - if !strings.HasPrefix(path, "Tables('") || !strings.HasSuffix(path, "')") { - return nil, fmt.Errorf("Expected the Table Name to be in the format `Tables('name')` but got %q", path) - } - - // strip off the `Table('')` - tableName := strings.TrimPrefix(uri.Path, "/Tables('") - tableName = strings.TrimSuffix(tableName, "')") - return &ResourceID{ - AccountName: *accountName, - TableName: tableName, - }, nil -} diff --git a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go b/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go deleted file mode 100644 index 05a61a8a7c9d..000000000000 --- a/vendor/github.com/tombuildsstuff/giovanni/storage/2020-08-04/table/tables/version.go +++ /dev/null @@ -1,14 +0,0 @@ -package tables - -import ( - "fmt" - - "github.com/tombuildsstuff/giovanni/version" -) - -// APIVersion is the version of the API used for all Storage API Operations -const APIVersion = "2020-08-04" - -func UserAgent() string { - return fmt.Sprintf("tombuildsstuff/giovanni/%s storage/%s", version.Number, APIVersion) -} From 50ffb7d198cdb4445a5eddcd721a6996c24a8eb4 Mon Sep 17 00:00:00 2001 From: yupwei68 Date: Thu, 27 May 2021 16:08:16 +0800 Subject: [PATCH 23/23] update --- .../internal/services/vmware/registration.go | 11 ++----- ...re_express_route_authorization_resource.go | 33 +++++++++---------- ...press_route_authorization_resource_test.go | 9 +++-- 3 files changed, 22 insertions(+), 31 deletions(-) diff --git a/azurerm/internal/services/vmware/registration.go b/azurerm/internal/services/vmware/registration.go index 976c061fa6d1..fae7872a2df3 100644 --- a/azurerm/internal/services/vmware/registration.go +++ b/azurerm/internal/services/vmware/registration.go @@ -24,17 +24,10 @@ func (r Registration) SupportedDataSources() map[string]*pluginsdk.Resource { } // SupportedResources returns the supported Resources supported by this Service -<<<<<<< HEAD -func (r Registration) SupportedResources() map[string]*schema.Resource { - return map[string]*schema.Resource{ +func (r Registration) SupportedResources() map[string]*pluginsdk.Resource { + return map[string]*pluginsdk.Resource{ "azurerm_vmware_private_cloud": resourceVmwarePrivateCloud(), "azurerm_vmware_cluster": resourceVmwareCluster(), "azurerm_vmware_express_route_authorization": resourceVmwareExpressRouteAuthorization(), -======= -func (r Registration) SupportedResources() map[string]*pluginsdk.Resource { - return map[string]*pluginsdk.Resource{ - "azurerm_vmware_private_cloud": resourceVmwarePrivateCloud(), - "azurerm_vmware_cluster": resourceVmwareCluster(), ->>>>>>> 0a29f734f5406e4772c65b871df5ef871454ab81 } } diff --git a/azurerm/internal/services/vmware/vmware_express_route_authorization_resource.go b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource.go index 242cead1239b..2a134d6d8d43 100644 --- a/azurerm/internal/services/vmware/vmware_express_route_authorization_resource.go +++ b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource.go @@ -6,63 +6,62 @@ import ( "time" "github.com/Azure/azure-sdk-for-go/services/avs/mgmt/2020-03-20/avs" - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/vmware/parse" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/vmware/validate" - azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema" + "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/pluginsdk" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/validation" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils" ) -func resourceVmwareExpressRouteAuthorization() *schema.Resource { - return &schema.Resource{ +func resourceVmwareExpressRouteAuthorization() *pluginsdk.Resource { + return &pluginsdk.Resource{ Create: resourceVmwareExpressRouteAuthorizationCreate, Read: resourceVmwareExpressRouteAuthorizationRead, Delete: resourceVmwareExpressRouteAuthorizationDelete, - Timeouts: &schema.ResourceTimeout{ - Create: schema.DefaultTimeout(30 * time.Minute), - Read: schema.DefaultTimeout(5 * time.Minute), - Delete: schema.DefaultTimeout(30 * time.Minute), + Timeouts: &pluginsdk.ResourceTimeout{ + Create: pluginsdk.DefaultTimeout(30 * time.Minute), + Read: pluginsdk.DefaultTimeout(5 * time.Minute), + Delete: pluginsdk.DefaultTimeout(30 * time.Minute), }, - Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error { + Importer: pluginsdk.ImporterValidatingResourceId(func(id string) error { _, err := parse.ExpressRouteAuthorizationID(id) return err }), - Schema: map[string]*schema.Schema{ + Schema: map[string]*pluginsdk.Schema{ "name": { - Type: schema.TypeString, + Type: pluginsdk.TypeString, Required: true, ForceNew: true, ValidateFunc: validation.StringIsNotEmpty, }, "private_cloud_id": { - Type: schema.TypeString, + Type: pluginsdk.TypeString, Required: true, ForceNew: true, ValidateFunc: validate.PrivateCloudID, }, "express_route_authorization_id": { - Type: schema.TypeString, + Type: pluginsdk.TypeString, Computed: true, }, "express_route_authorization_key": { - Type: schema.TypeString, + Type: pluginsdk.TypeString, Computed: true, Sensitive: true, }, }, } } -func resourceVmwareExpressRouteAuthorizationCreate(d *schema.ResourceData, meta interface{}) error { +func resourceVmwareExpressRouteAuthorizationCreate(d *pluginsdk.ResourceData, meta interface{}) error { subscriptionId := meta.(*clients.Client).Account.SubscriptionId client := meta.(*clients.Client).Vmware.AuthorizationClient ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d) @@ -101,7 +100,7 @@ func resourceVmwareExpressRouteAuthorizationCreate(d *schema.ResourceData, meta return resourceVmwareExpressRouteAuthorizationRead(d, meta) } -func resourceVmwareExpressRouteAuthorizationRead(d *schema.ResourceData, meta interface{}) error { +func resourceVmwareExpressRouteAuthorizationRead(d *pluginsdk.ResourceData, meta interface{}) error { subscriptionId := meta.(*clients.Client).Account.SubscriptionId client := meta.(*clients.Client).Vmware.AuthorizationClient ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d) @@ -131,7 +130,7 @@ func resourceVmwareExpressRouteAuthorizationRead(d *schema.ResourceData, meta in return nil } -func resourceVmwareExpressRouteAuthorizationDelete(d *schema.ResourceData, meta interface{}) error { +func resourceVmwareExpressRouteAuthorizationDelete(d *pluginsdk.ResourceData, meta interface{}) error { client := meta.(*clients.Client).Vmware.AuthorizationClient ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d) defer cancel() diff --git a/azurerm/internal/services/vmware/vmware_express_route_authorization_resource_test.go b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource_test.go index fbef5930b197..bea36e6eafe4 100644 --- a/azurerm/internal/services/vmware/vmware_express_route_authorization_resource_test.go +++ b/azurerm/internal/services/vmware/vmware_express_route_authorization_resource_test.go @@ -5,7 +5,6 @@ import ( "fmt" "testing" - "github.com/hashicorp/terraform-plugin-sdk/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/terraform" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance" "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance/check" @@ -21,10 +20,10 @@ func TestAccVmwareExpressRouteAuthorization_basic(t *testing.T) { data := acceptance.BuildTestData(t, "azurerm_vmware_express_route_authorization", "test") r := VmwareExpressRouteAuthorizationResource{} - data.ResourceTest(t, r, []resource.TestStep{ + data.ResourceTest(t, r, []acceptance.TestStep{ { Config: r.basic(data), - Check: resource.ComposeTestCheckFunc( + Check: acceptance.ComposeTestCheckFunc( check.That(data.ResourceName).ExistsInAzure(r), check.That(data.ResourceName).Key("express_route_authorization_id").Exists(), check.That(data.ResourceName).Key("express_route_authorization_key").Exists(), @@ -38,10 +37,10 @@ func TestAccVmwareExpressRouteAuthorization_requiresImport(t *testing.T) { data := acceptance.BuildTestData(t, "azurerm_vmware_express_route_authorization", "test") r := VmwareExpressRouteAuthorizationResource{} - data.ResourceTest(t, r, []resource.TestStep{ + data.ResourceTest(t, r, []acceptance.TestStep{ { Config: r.basic(data), - Check: resource.ComposeTestCheckFunc( + Check: acceptance.ComposeTestCheckFunc( check.That(data.ResourceName).ExistsInAzure(r), ), },