diff --git a/azurerm/config.go b/azurerm/config.go
index b80f2cc57cbf..d80d7e515063 100644
--- a/azurerm/config.go
+++ b/azurerm/config.go
@@ -27,6 +27,7 @@ import (
"github.com/Azure/azure-sdk-for-go/arm/sql"
"github.com/Azure/azure-sdk-for-go/arm/storage"
"github.com/Azure/azure-sdk-for-go/arm/trafficmanager"
+ "github.com/Azure/azure-sdk-for-go/arm/web"
keyVault "github.com/Azure/azure-sdk-for-go/dataplane/keyvault"
mainStorage "github.com/Azure/azure-sdk-for-go/storage"
"github.com/Azure/go-autorest/autorest"
@@ -119,9 +120,13 @@ type ArmClient struct {
sqlElasticPoolsClient sql.ElasticPoolsClient
sqlServersClient sql.ServersClient
+ appServicePlansClient web.AppServicePlansClient
+
appInsightsClient appinsights.ComponentsClient
servicePrincipalsClient graphrbac.ServicePrincipalsClient
+
+ appsClient web.AppsClient
}
func withRequestLogging() autorest.SendDecorator {
@@ -549,6 +554,12 @@ func (c *Config) getArmClient() (*ArmClient, error) {
sqlsrv.Sender = autorest.CreateSender(withRequestLogging())
client.sqlServersClient = sqlsrv
+ aspc := web.NewAppServicePlansClientWithBaseURI(endpoint, c.SubscriptionID)
+ setUserAgent(&aspc.Client)
+ aspc.Authorizer = auth
+ aspc.Sender = autorest.CreateSender(withRequestLogging())
+ client.appServicePlansClient = aspc
+
ai := appinsights.NewComponentsClientWithBaseURI(endpoint, c.SubscriptionID)
setUserAgent(&ai.Client)
ai.Authorizer = auth
@@ -561,6 +572,12 @@ func (c *Config) getArmClient() (*ArmClient, error) {
spc.Sender = autorest.CreateSender(withRequestLogging())
client.servicePrincipalsClient = spc
+ ac := web.NewAppsClientWithBaseURI(endpoint, c.SubscriptionID)
+ setUserAgent(&ac.Client)
+ ac.Authorizer = auth
+ ac.Sender = autorest.CreateSender(withRequestLogging())
+ client.appsClient = ac
+
kvc := keyvault.NewVaultsClientWithBaseURI(endpoint, c.SubscriptionID)
setUserAgent(&kvc.Client)
kvc.Authorizer = auth
diff --git a/azurerm/import_arm_app_service_plan_test.go b/azurerm/import_arm_app_service_plan_test.go
new file mode 100644
index 000000000000..6e7445789674
--- /dev/null
+++ b/azurerm/import_arm_app_service_plan_test.go
@@ -0,0 +1,100 @@
+package azurerm
+
+import (
+ "testing"
+
+ "github.com/hashicorp/terraform/helper/acctest"
+ "github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccAzureRMAppServicePlan_importBasic(t *testing.T) {
+ resourceName := "azurerm_app_service_plan.test"
+
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_basic(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ },
+ {
+ ResourceName: resourceName,
+ ImportState: true,
+ ImportStateVerify: true,
+ },
+ },
+ })
+}
+
+func TestAccAzureRMAppServicePlan_importStandard(t *testing.T) {
+ resourceName := "azurerm_app_service_plan.test"
+
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_standard(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ },
+ {
+ ResourceName: resourceName,
+ ImportState: true,
+ ImportStateVerify: true,
+ },
+ },
+ })
+}
+
+func TestAccAzureRMAppServicePlan_importPremium(t *testing.T) {
+ resourceName := "azurerm_app_service_plan.test"
+
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_premium(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ },
+ {
+ ResourceName: resourceName,
+ ImportState: true,
+ ImportStateVerify: true,
+ },
+ },
+ })
+}
+
+func TestAccAzureRMAppServicePlan_importComplete(t *testing.T) {
+ resourceName := "azurerm_app_service_plan.test"
+
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_complete(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ },
+ {
+ ResourceName: resourceName,
+ ImportState: true,
+ ImportStateVerify: true,
+ },
+ },
+ })
+}
diff --git a/azurerm/provider.go b/azurerm/provider.go
index 50c0e79a9c38..98092eabb107 100644
--- a/azurerm/provider.go
+++ b/azurerm/provider.go
@@ -139,6 +139,8 @@ func Provider() terraform.ResourceProvider {
"azurerm_virtual_network": resourceArmVirtualNetwork(),
"azurerm_virtual_network_peering": resourceArmVirtualNetworkPeering(),
+ "azurerm_app_service_plan": resourceArmAppServicePlan(),
+
// These resources use the Riviera SDK
"azurerm_resource_group": resourceArmResourceGroup(),
"azurerm_search_service": resourceArmSearchService(),
diff --git a/azurerm/resource_arm_app_service_plan.go b/azurerm/resource_arm_app_service_plan.go
new file mode 100644
index 000000000000..0f934545c891
--- /dev/null
+++ b/azurerm/resource_arm_app_service_plan.go
@@ -0,0 +1,259 @@
+package azurerm
+
+import (
+ "fmt"
+ "log"
+
+ "github.com/Azure/azure-sdk-for-go/arm/web"
+ "github.com/hashicorp/terraform/helper/schema"
+ "github.com/jen20/riviera/azure"
+)
+
+func resourceArmAppServicePlan() *schema.Resource {
+ return &schema.Resource{
+ Create: resourceArmAppServicePlanCreateUpdate,
+ Read: resourceArmAppServicePlanRead,
+ Update: resourceArmAppServicePlanCreateUpdate,
+ Delete: resourceArmAppServicePlanDelete,
+ Importer: &schema.ResourceImporter{
+ State: schema.ImportStatePassthrough,
+ },
+
+ Schema: map[string]*schema.Schema{
+ "name": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+
+ "resource_group_name": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+
+ "location": locationSchema(),
+
+ "sku": {
+ Type: schema.TypeList,
+ Required: true,
+ MaxItems: 1,
+ Elem: &schema.Resource{
+ Schema: map[string]*schema.Schema{
+ "tier": {
+ Type: schema.TypeString,
+ Required: true,
+ },
+ "size": {
+ Type: schema.TypeString,
+ Required: true,
+ },
+ "capacity": {
+ Type: schema.TypeInt,
+ Optional: true,
+ Computed: true,
+ },
+ },
+ },
+ },
+
+ "properties": {
+ Type: schema.TypeList,
+ Optional: true,
+ Computed: true,
+ MaxItems: 1,
+ Elem: &schema.Resource{
+ Schema: map[string]*schema.Schema{
+ "reserved": {
+ Type: schema.TypeBool,
+ Optional: true,
+ Default: false,
+ },
+ "per_site_scaling": {
+ Type: schema.TypeBool,
+ Optional: true,
+ Default: false,
+ },
+ },
+ },
+ },
+
+ "maximum_number_of_workers": {
+ Type: schema.TypeInt,
+ Computed: true,
+ },
+
+ "tags": tagsSchema(),
+ },
+ }
+}
+
+func resourceArmAppServicePlanCreateUpdate(d *schema.ResourceData, meta interface{}) error {
+ client := meta.(*ArmClient).appServicePlansClient
+
+ log.Printf("[INFO] preparing arguments for AzureRM App Service Plan creation.")
+
+ resGroup := d.Get("resource_group_name").(string)
+ name := d.Get("name").(string)
+ location := d.Get("location").(string)
+ tags := d.Get("tags").(map[string]interface{})
+
+ sku := expandAzureRmAppServicePlanSku(d)
+ properties := expandAppServicePlanProperties(d)
+
+ appServicePlan := web.AppServicePlan{
+ Location: &location,
+ AppServicePlanProperties: properties,
+ Tags: expandTags(tags),
+ Sku: &sku,
+ }
+
+ _, createErr := client.CreateOrUpdate(resGroup, name, appServicePlan, make(chan struct{}))
+ err := <-createErr
+ if err != nil {
+ return err
+ }
+
+ read, err := client.Get(resGroup, name)
+ if err != nil {
+ return err
+ }
+ if read.ID == nil {
+ return fmt.Errorf("Cannot read AzureRM App Service Plan %s (resource group %s) ID", name, resGroup)
+ }
+
+ d.SetId(*read.ID)
+
+ return resourceArmAppServicePlanRead(d, meta)
+}
+
+func resourceArmAppServicePlanRead(d *schema.ResourceData, meta interface{}) error {
+ client := meta.(*ArmClient).appServicePlansClient
+
+ id, err := parseAzureResourceID(d.Id())
+ if err != nil {
+ return err
+ }
+
+ log.Printf("[DEBUG] Reading Azure App Service Plan %s", id)
+
+ resGroup := id.ResourceGroup
+ name := id.Path["serverfarms"]
+
+ resp, err := client.Get(resGroup, name)
+ if err != nil {
+ if responseWasNotFound(resp.Response) {
+ d.SetId("")
+ return nil
+ }
+
+ return fmt.Errorf("Error making Read request on Azure App Service Plan %s: %+v", name, err)
+ }
+
+ d.Set("name", name)
+ d.Set("resource_group_name", resGroup)
+ d.Set("location", azureRMNormalizeLocation(*resp.Location))
+
+ if props := resp.AppServicePlanProperties; props != nil {
+ d.Set("properties", flattenAppServiceProperties(props))
+
+ if props.MaximumNumberOfWorkers != nil {
+ d.Set("maximum_number_of_workers", int(*props.MaximumNumberOfWorkers))
+ }
+ }
+
+ if sku := resp.Sku; sku != nil {
+ d.Set("sku", flattenAppServicePlanSku(sku))
+ }
+
+ flattenAndSetTags(d, resp.Tags)
+
+ return nil
+}
+
+func resourceArmAppServicePlanDelete(d *schema.ResourceData, meta interface{}) error {
+ client := meta.(*ArmClient).appServicePlansClient
+
+ id, err := parseAzureResourceID(d.Id())
+ if err != nil {
+ return err
+ }
+ resGroup := id.ResourceGroup
+ name := id.Path["serverfarms"]
+
+ log.Printf("[DEBUG] Deleting app service plan %s: %s", resGroup, name)
+
+ _, err = client.Delete(resGroup, name)
+
+ return err
+}
+
+func expandAzureRmAppServicePlanSku(d *schema.ResourceData) web.SkuDescription {
+ configs := d.Get("sku").([]interface{})
+ config := configs[0].(map[string]interface{})
+
+ tier := config["tier"].(string)
+ size := config["size"].(string)
+
+ sku := web.SkuDescription{
+ Name: &size,
+ Tier: &tier,
+ Size: &size,
+ }
+
+ if v, ok := config["capacity"]; ok {
+ capacity := v.(int)
+ sku.Capacity = azure.Int32(int32(capacity))
+ }
+
+ return sku
+}
+
+func flattenAppServicePlanSku(profile *web.SkuDescription) []interface{} {
+ skus := make([]interface{}, 0, 1)
+ sku := make(map[string]interface{}, 2)
+
+ sku["tier"] = *profile.Tier
+ sku["size"] = *profile.Size
+
+ if profile.Capacity != nil {
+ sku["capacity"] = *profile.Capacity
+ }
+
+ skus = append(skus, sku)
+
+ return skus
+}
+
+func expandAppServicePlanProperties(d *schema.ResourceData) *web.AppServicePlanProperties {
+ configs := d.Get("properties").([]interface{})
+ properties := web.AppServicePlanProperties{}
+ if len(configs) == 0 {
+ return &properties
+ }
+ config := configs[0].(map[string]interface{})
+
+ perSiteScaling := config["per_site_scaling"].(bool)
+ properties.PerSiteScaling = azure.Bool(perSiteScaling)
+
+ reserved := config["reserved"].(bool)
+ properties.Reserved = azure.Bool(reserved)
+
+ return &properties
+}
+
+func flattenAppServiceProperties(props *web.AppServicePlanProperties) []interface{} {
+ result := make([]interface{}, 0, 1)
+ properties := make(map[string]interface{}, 0)
+
+ if props.PerSiteScaling != nil {
+ properties["per_site_scaling"] = *props.PerSiteScaling
+ }
+
+ if props.Reserved != nil {
+ properties["reserved"] = *props.Reserved
+ }
+
+ result = append(result, properties)
+ return result
+}
diff --git a/azurerm/resource_arm_app_service_plan_test.go b/azurerm/resource_arm_app_service_plan_test.go
new file mode 100644
index 000000000000..a296b6fe27e9
--- /dev/null
+++ b/azurerm/resource_arm_app_service_plan_test.go
@@ -0,0 +1,287 @@
+package azurerm
+
+import (
+ "fmt"
+ "net/http"
+ "testing"
+
+ "github.com/hashicorp/terraform/helper/acctest"
+ "github.com/hashicorp/terraform/helper/resource"
+ "github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAzureRMAppServicePlan_basic(t *testing.T) {
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_basic(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMAppServicePlanExists("azurerm_app_service_plan.test"),
+ ),
+ },
+ },
+ })
+}
+
+func TestAccAzureRMAppServicePlan_standard(t *testing.T) {
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_standard(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMAppServicePlanExists("azurerm_app_service_plan.test"),
+ ),
+ },
+ },
+ })
+}
+
+func TestAccAzureRMAppServicePlan_premium(t *testing.T) {
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_premium(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMAppServicePlanExists("azurerm_app_service_plan.test"),
+ ),
+ },
+ },
+ })
+}
+
+func TestAccAzureRMAppServicePlan_premiumUpdated(t *testing.T) {
+ resourceName := "azurerm_app_service_plan.test"
+ ri := acctest.RandInt()
+ location := testLocation()
+ config := testAccAzureRMAppServicePlan_premium(ri, location)
+ updatedConfig := testAccAzureRMAppServicePlan_premiumUpdated(ri, location)
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMAppServicePlanExists(resourceName),
+ resource.TestCheckResourceAttr(resourceName, "sku.0.capacity", "1"),
+ ),
+ },
+ {
+ Config: updatedConfig,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMAppServicePlanExists(resourceName),
+ resource.TestCheckResourceAttr(resourceName, "sku.0.capacity", "2"),
+ ),
+ },
+ },
+ })
+}
+
+func TestAccAzureRMAppServicePlan_complete(t *testing.T) {
+ resourceName := "azurerm_app_service_plan.test"
+ ri := acctest.RandInt()
+ config := testAccAzureRMAppServicePlan_complete(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMAppServicePlanDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMAppServicePlanExists(resourceName),
+ resource.TestCheckResourceAttr(resourceName, "properties.0.per_site_scaling", "true"),
+ resource.TestCheckResourceAttr(resourceName, "properties.0.reserved", "false"),
+ ),
+ },
+ },
+ })
+}
+
+func testCheckAzureRMAppServicePlanDestroy(s *terraform.State) error {
+ conn := testAccProvider.Meta().(*ArmClient).appServicePlansClient
+
+ for _, rs := range s.RootModule().Resources {
+ if rs.Type != "azurerm_app_service_plan" {
+ continue
+ }
+
+ name := rs.Primary.Attributes["name"]
+ resourceGroup := rs.Primary.Attributes["resource_group_name"]
+
+ resp, err := conn.Get(resourceGroup, name)
+
+ if err != nil {
+
+ if responseWasNotFound(resp.Response) {
+ return nil
+ }
+
+ return err
+ }
+
+ return fmt.Errorf("App Service Plan still exists:\n%#v", resp)
+ }
+
+ return nil
+}
+
+func testCheckAzureRMAppServicePlanExists(name string) resource.TestCheckFunc {
+ return func(s *terraform.State) error {
+ // Ensure we have enough information in state to look up in API
+ rs, ok := s.RootModule().Resources[name]
+ if !ok {
+ return fmt.Errorf("Not found: %s", name)
+ }
+
+ appServicePlanName := rs.Primary.Attributes["name"]
+ resourceGroup, hasResourceGroup := rs.Primary.Attributes["resource_group_name"]
+ if !hasResourceGroup {
+ return fmt.Errorf("Bad: no resource group found in state for App Service Plan: %s", appServicePlanName)
+ }
+
+ conn := testAccProvider.Meta().(*ArmClient).appServicePlansClient
+
+ resp, err := conn.Get(resourceGroup, appServicePlanName)
+ if err != nil {
+ return fmt.Errorf("Bad: Get on appServicePlansClient: %s", err)
+ }
+
+ if resp.StatusCode == http.StatusNotFound {
+ return fmt.Errorf("Bad: App Service Plan %q (resource group: %q) does not exist", appServicePlanName, resourceGroup)
+ }
+
+ return nil
+ }
+}
+
+func testAccAzureRMAppServicePlan_basic(rInt int, location string) string {
+ return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+ name = "acctestRG-%d"
+ location = "%s"
+}
+
+resource "azurerm_app_service_plan" "test" {
+ name = "acctestASP-%d"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ tier = "Basic"
+ size = "B1"
+ }
+}
+`, rInt, location, rInt)
+}
+
+func testAccAzureRMAppServicePlan_standard(rInt int, location string) string {
+ return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+ name = "acctestRG-%d"
+ location = "%s"
+}
+
+resource "azurerm_app_service_plan" "test" {
+ name = "acctestASP-%d"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ tier = "Standard"
+ size = "S1"
+ }
+}
+`, rInt, location, rInt)
+}
+
+func testAccAzureRMAppServicePlan_premium(rInt int, location string) string {
+ return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+ name = "acctestRG-%d"
+ location = "%s"
+}
+
+resource "azurerm_app_service_plan" "test" {
+ name = "acctestASP-%d"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ tier = "Premium"
+ size = "P1"
+ }
+}
+`, rInt, location, rInt)
+}
+
+func testAccAzureRMAppServicePlan_premiumUpdated(rInt int, location string) string {
+ return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+ name = "acctestRG-%d"
+ location = "%s"
+}
+
+resource "azurerm_app_service_plan" "test" {
+ name = "acctestASP-%d"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ tier = "Premium"
+ size = "P1"
+ capacity = 2
+ }
+}
+`, rInt, location, rInt)
+}
+
+func testAccAzureRMAppServicePlan_complete(rInt int, location string) string {
+ return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+ name = "acctestRG-%d"
+ location = "%s"
+}
+
+resource "azurerm_app_service_plan" "test" {
+ name = "acctestASP-%d"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ tier = "Standard"
+ size = "S1"
+ }
+
+ properties {
+ per_site_scaling = true
+ reserved = false
+ }
+
+ tags {
+ environment = "Test"
+ }
+}
+`, rInt, location, rInt)
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/apps.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/apps.go
new file mode 100755
index 000000000000..4515b48bc3ad
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/apps.go
@@ -0,0 +1,17607 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// AppsClient is the composite Swagger for WebSite Management Client
+type AppsClient struct {
+ ManagementClient
+}
+
+// NewAppsClient creates an instance of the AppsClient client.
+func NewAppsClient(subscriptionID string) AppsClient {
+ return NewAppsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewAppsClientWithBaseURI creates an instance of the AppsClient client.
+func NewAppsClientWithBaseURI(baseURI string, subscriptionID string) AppsClient {
+ return AppsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// AddPremierAddOn updates a named add-on of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. premierAddOnName is add-on name.
+// premierAddOn is a JSON representation of the edited premier add-on.
+func (client AppsClient) AddPremierAddOn(resourceGroupName string, name string, premierAddOnName string, premierAddOn PremierAddOn) (result PremierAddOn, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "AddPremierAddOn")
+ }
+
+ req, err := client.AddPremierAddOnPreparer(resourceGroupName, name, premierAddOnName, premierAddOn)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AddPremierAddOn", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.AddPremierAddOnSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AddPremierAddOn", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.AddPremierAddOnResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AddPremierAddOn", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// AddPremierAddOnPreparer prepares the AddPremierAddOn request.
+func (client AppsClient) AddPremierAddOnPreparer(resourceGroupName string, name string, premierAddOnName string, premierAddOn PremierAddOn) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "premierAddOnName": autorest.Encode("path", premierAddOnName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/premieraddons/{premierAddOnName}", pathParameters),
+ autorest.WithJSON(premierAddOn),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// AddPremierAddOnSender sends the AddPremierAddOn request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) AddPremierAddOnSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// AddPremierAddOnResponder handles the response to the AddPremierAddOn request. The method always
+// closes the http.Response Body.
+func (client AppsClient) AddPremierAddOnResponder(resp *http.Response) (result PremierAddOn, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// AddPremierAddOnSlot updates a named add-on of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. premierAddOnName is add-on name.
+// premierAddOn is a JSON representation of the edited premier add-on. slot is
+// name of the deployment slot. If a slot is not specified, the API will update
+// the named add-on for the production slot.
+func (client AppsClient) AddPremierAddOnSlot(resourceGroupName string, name string, premierAddOnName string, premierAddOn PremierAddOn, slot string) (result PremierAddOn, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "AddPremierAddOnSlot")
+ }
+
+ req, err := client.AddPremierAddOnSlotPreparer(resourceGroupName, name, premierAddOnName, premierAddOn, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AddPremierAddOnSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.AddPremierAddOnSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AddPremierAddOnSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.AddPremierAddOnSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AddPremierAddOnSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// AddPremierAddOnSlotPreparer prepares the AddPremierAddOnSlot request.
+func (client AppsClient) AddPremierAddOnSlotPreparer(resourceGroupName string, name string, premierAddOnName string, premierAddOn PremierAddOn, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "premierAddOnName": autorest.Encode("path", premierAddOnName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/premieraddons/{premierAddOnName}", pathParameters),
+ autorest.WithJSON(premierAddOn),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// AddPremierAddOnSlotSender sends the AddPremierAddOnSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) AddPremierAddOnSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// AddPremierAddOnSlotResponder handles the response to the AddPremierAddOnSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) AddPremierAddOnSlotResponder(resp *http.Response) (result PremierAddOn, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// AnalyzeCustomHostname analyze a custom hostname.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app hostName is custom hostname
+func (client AppsClient) AnalyzeCustomHostname(resourceGroupName string, name string, hostName string) (result CustomHostnameAnalysisResult, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "AnalyzeCustomHostname")
+ }
+
+ req, err := client.AnalyzeCustomHostnamePreparer(resourceGroupName, name, hostName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AnalyzeCustomHostname", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.AnalyzeCustomHostnameSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AnalyzeCustomHostname", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.AnalyzeCustomHostnameResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AnalyzeCustomHostname", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// AnalyzeCustomHostnamePreparer prepares the AnalyzeCustomHostname request.
+func (client AppsClient) AnalyzeCustomHostnamePreparer(resourceGroupName string, name string, hostName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(hostName) > 0 {
+ queryParameters["hostName"] = autorest.Encode("query", hostName)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/analyzeCustomHostname", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// AnalyzeCustomHostnameSender sends the AnalyzeCustomHostname request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) AnalyzeCustomHostnameSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// AnalyzeCustomHostnameResponder handles the response to the AnalyzeCustomHostname request. The method always
+// closes the http.Response Body.
+func (client AppsClient) AnalyzeCustomHostnameResponder(resp *http.Response) (result CustomHostnameAnalysisResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// AnalyzeCustomHostnameSlot analyze a custom hostname.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app slot is name of web app slot. If not
+// specified then will default to production slot. hostName is custom hostname
+func (client AppsClient) AnalyzeCustomHostnameSlot(resourceGroupName string, name string, slot string, hostName string) (result CustomHostnameAnalysisResult, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "AnalyzeCustomHostnameSlot")
+ }
+
+ req, err := client.AnalyzeCustomHostnameSlotPreparer(resourceGroupName, name, slot, hostName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AnalyzeCustomHostnameSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.AnalyzeCustomHostnameSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AnalyzeCustomHostnameSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.AnalyzeCustomHostnameSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "AnalyzeCustomHostnameSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// AnalyzeCustomHostnameSlotPreparer prepares the AnalyzeCustomHostnameSlot request.
+func (client AppsClient) AnalyzeCustomHostnameSlotPreparer(resourceGroupName string, name string, slot string, hostName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(hostName) > 0 {
+ queryParameters["hostName"] = autorest.Encode("query", hostName)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/analyzeCustomHostname", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// AnalyzeCustomHostnameSlotSender sends the AnalyzeCustomHostnameSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) AnalyzeCustomHostnameSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// AnalyzeCustomHostnameSlotResponder handles the response to the AnalyzeCustomHostnameSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) AnalyzeCustomHostnameSlotResponder(resp *http.Response) (result CustomHostnameAnalysisResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ApplySlotConfigToProduction applies the configuration settings from the
+// target slot onto the current slot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slotSwapEntity is jSON object that
+// contains the target slot name. See example.
+func (client AppsClient) ApplySlotConfigToProduction(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: slotSwapEntity,
+ Constraints: []validation.Constraint{{Target: "slotSwapEntity.TargetSlot", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "slotSwapEntity.PreserveVnet", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ApplySlotConfigToProduction")
+ }
+
+ req, err := client.ApplySlotConfigToProductionPreparer(resourceGroupName, name, slotSwapEntity)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ApplySlotConfigToProduction", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ApplySlotConfigToProductionSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ApplySlotConfigToProduction", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ApplySlotConfigToProductionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ApplySlotConfigToProduction", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ApplySlotConfigToProductionPreparer prepares the ApplySlotConfigToProduction request.
+func (client AppsClient) ApplySlotConfigToProductionPreparer(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/applySlotConfig", pathParameters),
+ autorest.WithJSON(slotSwapEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ApplySlotConfigToProductionSender sends the ApplySlotConfigToProduction request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ApplySlotConfigToProductionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ApplySlotConfigToProductionResponder handles the response to the ApplySlotConfigToProduction request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ApplySlotConfigToProductionResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// ApplySlotConfigurationSlot applies the configuration settings from the
+// target slot onto the current slot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slotSwapEntity is jSON object that
+// contains the target slot name. See example. slot is name of the source slot.
+// If a slot is not specified, the production slot is used as the source slot.
+func (client AppsClient) ApplySlotConfigurationSlot(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: slotSwapEntity,
+ Constraints: []validation.Constraint{{Target: "slotSwapEntity.TargetSlot", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "slotSwapEntity.PreserveVnet", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ApplySlotConfigurationSlot")
+ }
+
+ req, err := client.ApplySlotConfigurationSlotPreparer(resourceGroupName, name, slotSwapEntity, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ApplySlotConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ApplySlotConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ApplySlotConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ApplySlotConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ApplySlotConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ApplySlotConfigurationSlotPreparer prepares the ApplySlotConfigurationSlot request.
+func (client AppsClient) ApplySlotConfigurationSlotPreparer(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/applySlotConfig", pathParameters),
+ autorest.WithJSON(slotSwapEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ApplySlotConfigurationSlotSender sends the ApplySlotConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ApplySlotConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ApplySlotConfigurationSlotResponder handles the response to the ApplySlotConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ApplySlotConfigurationSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Backup creates a backup of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. request is backup configuration. You can
+// use the JSON response from the POST action as input here.
+func (client AppsClient) Backup(resourceGroupName string, name string, request BackupRequest) (result BackupItem, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: request,
+ Constraints: []validation.Constraint{{Target: "request.BackupRequestProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule.FrequencyInterval", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.KeepAtLeastOneBackup", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.RetentionPeriodInDays", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "Backup")
+ }
+
+ req, err := client.BackupPreparer(resourceGroupName, name, request)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Backup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.BackupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Backup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.BackupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Backup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// BackupPreparer prepares the Backup request.
+func (client AppsClient) BackupPreparer(resourceGroupName string, name string, request BackupRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/backup", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// BackupSender sends the Backup request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) BackupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// BackupResponder handles the response to the Backup request. The method always
+// closes the http.Response Body.
+func (client AppsClient) BackupResponder(resp *http.Response) (result BackupItem, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// BackupSlot creates a backup of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. request is backup configuration. You can
+// use the JSON response from the POST action as input here. slot is name of
+// the deployment slot. If a slot is not specified, the API will create a
+// backup for the production slot.
+func (client AppsClient) BackupSlot(resourceGroupName string, name string, request BackupRequest, slot string) (result BackupItem, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: request,
+ Constraints: []validation.Constraint{{Target: "request.BackupRequestProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule.FrequencyInterval", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.KeepAtLeastOneBackup", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.RetentionPeriodInDays", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "BackupSlot")
+ }
+
+ req, err := client.BackupSlotPreparer(resourceGroupName, name, request, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "BackupSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.BackupSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "BackupSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.BackupSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "BackupSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// BackupSlotPreparer prepares the BackupSlot request.
+func (client AppsClient) BackupSlotPreparer(resourceGroupName string, name string, request BackupRequest, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/backup", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// BackupSlotSender sends the BackupSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) BackupSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// BackupSlotResponder handles the response to the BackupSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) BackupSlotResponder(resp *http.Response) (result BackupItem, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateDeployment create a deployment for an app, a specific deployment slot,
+// and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is iD of an existing deployment.
+// deployment is deployment details.
+func (client AppsClient) CreateDeployment(resourceGroupName string, name string, ID string, deployment Deployment) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateDeployment")
+ }
+
+ req, err := client.CreateDeploymentPreparer(resourceGroupName, name, ID, deployment)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateDeployment", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateDeploymentSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateDeployment", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateDeploymentResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateDeployment", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateDeploymentPreparer prepares the CreateDeployment request.
+func (client AppsClient) CreateDeploymentPreparer(resourceGroupName string, name string, ID string, deployment Deployment) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/deployments/{id}", pathParameters),
+ autorest.WithJSON(deployment),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateDeploymentSender sends the CreateDeployment request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateDeploymentSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateDeploymentResponder handles the response to the CreateDeployment request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateDeploymentResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateDeploymentSlot create a deployment for an app, a specific deployment
+// slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is iD of an existing deployment. slot
+// is name of the deployment slot. If a slot is not specified, the API creates
+// a deployment for the production slot. deployment is deployment details.
+func (client AppsClient) CreateDeploymentSlot(resourceGroupName string, name string, ID string, slot string, deployment Deployment) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateDeploymentSlot")
+ }
+
+ req, err := client.CreateDeploymentSlotPreparer(resourceGroupName, name, ID, slot, deployment)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateDeploymentSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateDeploymentSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateDeploymentSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateDeploymentSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateDeploymentSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateDeploymentSlotPreparer prepares the CreateDeploymentSlot request.
+func (client AppsClient) CreateDeploymentSlotPreparer(resourceGroupName string, name string, ID string, slot string, deployment Deployment) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/deployments/{id}", pathParameters),
+ autorest.WithJSON(deployment),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateDeploymentSlotSender sends the CreateDeploymentSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateDeploymentSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateDeploymentSlotResponder handles the response to the CreateDeploymentSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateDeploymentSlotResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateInstanceDeployment create a deployment for an app, a specific
+// deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is iD of an existing deployment.
+// instanceID is iD of a specific scaled-out instance. This is the value of the
+// name property in the JSON response from "GET api/sites/{siteName}/instances"
+// deployment is deployment details.
+func (client AppsClient) CreateInstanceDeployment(resourceGroupName string, name string, ID string, instanceID string, deployment Deployment) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateInstanceDeployment")
+ }
+
+ req, err := client.CreateInstanceDeploymentPreparer(resourceGroupName, name, ID, instanceID, deployment)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateInstanceDeployment", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateInstanceDeploymentSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateInstanceDeployment", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateInstanceDeploymentResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateInstanceDeployment", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateInstanceDeploymentPreparer prepares the CreateInstanceDeployment request.
+func (client AppsClient) CreateInstanceDeploymentPreparer(resourceGroupName string, name string, ID string, instanceID string, deployment Deployment) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/instances/{instanceId}/deployments/{id}", pathParameters),
+ autorest.WithJSON(deployment),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateInstanceDeploymentSender sends the CreateInstanceDeployment request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateInstanceDeploymentSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateInstanceDeploymentResponder handles the response to the CreateInstanceDeployment request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateInstanceDeploymentResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateInstanceDeploymentSlot create a deployment for an app, a specific
+// deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is iD of an existing deployment. slot
+// is name of the deployment slot. If a slot is not specified, the API creates
+// a deployment for the production slot. instanceID is iD of a specific
+// scaled-out instance. This is the value of the name property in the JSON
+// response from "GET api/sites/{siteName}/instances" deployment is deployment
+// details.
+func (client AppsClient) CreateInstanceDeploymentSlot(resourceGroupName string, name string, ID string, slot string, instanceID string, deployment Deployment) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateInstanceDeploymentSlot")
+ }
+
+ req, err := client.CreateInstanceDeploymentSlotPreparer(resourceGroupName, name, ID, slot, instanceID, deployment)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateInstanceDeploymentSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateInstanceDeploymentSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateInstanceDeploymentSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateInstanceDeploymentSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateInstanceDeploymentSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateInstanceDeploymentSlotPreparer prepares the CreateInstanceDeploymentSlot request.
+func (client AppsClient) CreateInstanceDeploymentSlotPreparer(resourceGroupName string, name string, ID string, slot string, instanceID string, deployment Deployment) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/instances/{instanceId}/deployments/{id}", pathParameters),
+ autorest.WithJSON(deployment),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateInstanceDeploymentSlotSender sends the CreateInstanceDeploymentSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateInstanceDeploymentSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateInstanceDeploymentSlotResponder handles the response to the CreateInstanceDeploymentSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateInstanceDeploymentSlotResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdate creates a new web, mobile, or API app in an existing resource
+// group, or updates an existing app. This method may poll for completion.
+// Polling can be canceled by passing the cancel channel argument. The channel
+// will be used to cancel polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is unique name of the app to create or update. To create or
+// update a deployment slot, use the {slot} parameter. siteEnvelope is a JSON
+// representation of the app properties. See example. skipDNSRegistration is if
+// true web app hostname is not registered with DNS on creation. This parameter
+// is
+// only used for app creation skipCustomDomainVerification is if true, custom
+// (non *.azurewebsites.net) domains associated with web app are not verified.
+// forceDNSRegistration is if true, web app hostname is force registered with
+// DNS TTLInSeconds is time to live in seconds for web app's default domain
+// name
+func (client AppsClient) CreateOrUpdate(resourceGroupName string, name string, siteEnvelope Site, skipDNSRegistration *bool, skipCustomDomainVerification *bool, forceDNSRegistration *bool, TTLInSeconds string, cancel <-chan struct{}) (<-chan Site, <-chan error) {
+ resultChan := make(chan Site, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: siteEnvelope,
+ Constraints: []validation.Constraint{{Target: "siteEnvelope.SiteProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.SiteConfig", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.SiteConfig.Push", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.SiteConfig.Push.IsPushEnabled", Name: validation.Null, Rule: true, Chain: nil}}},
+ }},
+ {Target: "siteEnvelope.SiteProperties.CloningInfo", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.CloningInfo.SourceWebAppID", Name: validation.Null, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdate")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result Site
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdatePreparer(resourceGroupName, name, siteEnvelope, skipDNSRegistration, skipCustomDomainVerification, forceDNSRegistration, TTLInSeconds, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client AppsClient) CreateOrUpdatePreparer(resourceGroupName string, name string, siteEnvelope Site, skipDNSRegistration *bool, skipCustomDomainVerification *bool, forceDNSRegistration *bool, TTLInSeconds string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if skipDNSRegistration != nil {
+ queryParameters["skipDnsRegistration"] = autorest.Encode("query", *skipDNSRegistration)
+ }
+ if skipCustomDomainVerification != nil {
+ queryParameters["skipCustomDomainVerification"] = autorest.Encode("query", *skipCustomDomainVerification)
+ }
+ if forceDNSRegistration != nil {
+ queryParameters["forceDnsRegistration"] = autorest.Encode("query", *forceDNSRegistration)
+ }
+ if len(TTLInSeconds) > 0 {
+ queryParameters["ttlInSeconds"] = autorest.Encode("query", TTLInSeconds)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}", pathParameters),
+ autorest.WithJSON(siteEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateResponder(resp *http.Response) (result Site, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateConfiguration updates the configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteConfig is jSON representation of a
+// SiteConfig object. See example.
+func (client AppsClient) CreateOrUpdateConfiguration(resourceGroupName string, name string, siteConfig SiteConfigResource) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: siteConfig,
+ Constraints: []validation.Constraint{{Target: "siteConfig.SiteConfig", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteConfig.SiteConfig.Push", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteConfig.SiteConfig.Push.IsPushEnabled", Name: validation.Null, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateConfiguration")
+ }
+
+ req, err := client.CreateOrUpdateConfigurationPreparer(resourceGroupName, name, siteConfig)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateConfigurationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateConfiguration", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateConfigurationPreparer prepares the CreateOrUpdateConfiguration request.
+func (client AppsClient) CreateOrUpdateConfigurationPreparer(resourceGroupName string, name string, siteConfig SiteConfigResource) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/web", pathParameters),
+ autorest.WithJSON(siteConfig),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateConfigurationSender sends the CreateOrUpdateConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateConfigurationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateConfigurationResponder handles the response to the CreateOrUpdateConfiguration request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateConfigurationResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateConfigurationSlot updates the configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteConfig is jSON representation of a
+// SiteConfig object. See example. slot is name of the deployment slot. If a
+// slot is not specified, the API will update configuration for the production
+// slot.
+func (client AppsClient) CreateOrUpdateConfigurationSlot(resourceGroupName string, name string, siteConfig SiteConfigResource, slot string) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: siteConfig,
+ Constraints: []validation.Constraint{{Target: "siteConfig.SiteConfig", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteConfig.SiteConfig.Push", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteConfig.SiteConfig.Push.IsPushEnabled", Name: validation.Null, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateConfigurationSlot")
+ }
+
+ req, err := client.CreateOrUpdateConfigurationSlotPreparer(resourceGroupName, name, siteConfig, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateConfigurationSlotPreparer prepares the CreateOrUpdateConfigurationSlot request.
+func (client AppsClient) CreateOrUpdateConfigurationSlotPreparer(resourceGroupName string, name string, siteConfig SiteConfigResource, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/web", pathParameters),
+ autorest.WithJSON(siteConfig),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateConfigurationSlotSender sends the CreateOrUpdateConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateConfigurationSlotResponder handles the response to the CreateOrUpdateConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateConfigurationSlotResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateDomainOwnershipIdentifier creates a domain ownership
+// identifier for web app, or updates an existing ownership identifier.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier. domainOwnershipIdentifier is a JSON
+// representation of the domain ownership properties.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifier(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier) (result Identifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifier")
+ }
+
+ req, err := client.CreateOrUpdateDomainOwnershipIdentifierPreparer(resourceGroupName, name, domainOwnershipIdentifierName, domainOwnershipIdentifier)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateDomainOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateDomainOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateDomainOwnershipIdentifierPreparer prepares the CreateOrUpdateDomainOwnershipIdentifier request.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithJSON(domainOwnershipIdentifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateDomainOwnershipIdentifierSender sends the CreateOrUpdateDomainOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateDomainOwnershipIdentifierResponder handles the response to the CreateOrUpdateDomainOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierResponder(resp *http.Response) (result Identifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateDomainOwnershipIdentifierSlot creates a domain ownership
+// identifier for web app, or updates an existing ownership identifier.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier. domainOwnershipIdentifier is a JSON
+// representation of the domain ownership properties. slot is name of the
+// deployment slot. If a slot is not specified, the API will delete the binding
+// for the production slot.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSlot(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier, slot string) (result Identifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifierSlot")
+ }
+
+ req, err := client.CreateOrUpdateDomainOwnershipIdentifierSlotPreparer(resourceGroupName, name, domainOwnershipIdentifierName, domainOwnershipIdentifier, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifierSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateDomainOwnershipIdentifierSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifierSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateDomainOwnershipIdentifierSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateDomainOwnershipIdentifierSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateDomainOwnershipIdentifierSlotPreparer prepares the CreateOrUpdateDomainOwnershipIdentifierSlot request.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSlotPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithJSON(domainOwnershipIdentifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateDomainOwnershipIdentifierSlotSender sends the CreateOrUpdateDomainOwnershipIdentifierSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateDomainOwnershipIdentifierSlotResponder handles the response to the CreateOrUpdateDomainOwnershipIdentifierSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateDomainOwnershipIdentifierSlotResponder(resp *http.Response) (result Identifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateHostNameBinding creates a hostname binding for an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. hostName is hostname in the hostname
+// binding. hostNameBinding is binding details. This is the JSON representation
+// of a HostNameBinding object.
+func (client AppsClient) CreateOrUpdateHostNameBinding(resourceGroupName string, name string, hostName string, hostNameBinding HostNameBinding) (result HostNameBinding, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateHostNameBinding")
+ }
+
+ req, err := client.CreateOrUpdateHostNameBindingPreparer(resourceGroupName, name, hostName, hostNameBinding)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHostNameBinding", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateHostNameBindingSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHostNameBinding", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateHostNameBindingResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHostNameBinding", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateHostNameBindingPreparer prepares the CreateOrUpdateHostNameBinding request.
+func (client AppsClient) CreateOrUpdateHostNameBindingPreparer(resourceGroupName string, name string, hostName string, hostNameBinding HostNameBinding) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hostName": autorest.Encode("path", hostName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hostNameBindings/{hostName}", pathParameters),
+ autorest.WithJSON(hostNameBinding),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateHostNameBindingSender sends the CreateOrUpdateHostNameBinding request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateHostNameBindingSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateHostNameBindingResponder handles the response to the CreateOrUpdateHostNameBinding request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateHostNameBindingResponder(resp *http.Response) (result HostNameBinding, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateHostNameBindingSlot creates a hostname binding for an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. hostName is hostname in the hostname
+// binding. hostNameBinding is binding details. This is the JSON representation
+// of a HostNameBinding object. slot is name of the deployment slot. If a slot
+// is not specified, the API will create a binding for the production slot.
+func (client AppsClient) CreateOrUpdateHostNameBindingSlot(resourceGroupName string, name string, hostName string, hostNameBinding HostNameBinding, slot string) (result HostNameBinding, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateHostNameBindingSlot")
+ }
+
+ req, err := client.CreateOrUpdateHostNameBindingSlotPreparer(resourceGroupName, name, hostName, hostNameBinding, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHostNameBindingSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateHostNameBindingSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHostNameBindingSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateHostNameBindingSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHostNameBindingSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateHostNameBindingSlotPreparer prepares the CreateOrUpdateHostNameBindingSlot request.
+func (client AppsClient) CreateOrUpdateHostNameBindingSlotPreparer(resourceGroupName string, name string, hostName string, hostNameBinding HostNameBinding, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hostName": autorest.Encode("path", hostName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hostNameBindings/{hostName}", pathParameters),
+ autorest.WithJSON(hostNameBinding),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateHostNameBindingSlotSender sends the CreateOrUpdateHostNameBindingSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateHostNameBindingSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateHostNameBindingSlotResponder handles the response to the CreateOrUpdateHostNameBindingSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateHostNameBindingSlotResponder(resp *http.Response) (result HostNameBinding, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateHybridConnection creates a new Hybrid Connection using a
+// Service Bus relay.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection connectionEnvelope is the details of the hybrid connection
+func (client AppsClient) CreateOrUpdateHybridConnection(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateHybridConnection")
+ }
+
+ req, err := client.CreateOrUpdateHybridConnectionPreparer(resourceGroupName, name, namespaceName, relayName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHybridConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateHybridConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHybridConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHybridConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateHybridConnectionPreparer prepares the CreateOrUpdateHybridConnection request.
+func (client AppsClient) CreateOrUpdateHybridConnectionPreparer(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateHybridConnectionSender sends the CreateOrUpdateHybridConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateHybridConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateHybridConnectionResponder handles the response to the CreateOrUpdateHybridConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateHybridConnectionResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateHybridConnectionSlot creates a new Hybrid Connection using a
+// Service Bus relay.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection connectionEnvelope is the details of the hybrid connection slot
+// is the name of the slot for the web app.
+func (client AppsClient) CreateOrUpdateHybridConnectionSlot(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection, slot string) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateHybridConnectionSlot")
+ }
+
+ req, err := client.CreateOrUpdateHybridConnectionSlotPreparer(resourceGroupName, name, namespaceName, relayName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHybridConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateHybridConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHybridConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateHybridConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateHybridConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateHybridConnectionSlotPreparer prepares the CreateOrUpdateHybridConnectionSlot request.
+func (client AppsClient) CreateOrUpdateHybridConnectionSlotPreparer(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateHybridConnectionSlotSender sends the CreateOrUpdateHybridConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateHybridConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateHybridConnectionSlotResponder handles the response to the CreateOrUpdateHybridConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateHybridConnectionSlotResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateRelayServiceConnection creates a new hybrid connection
+// configuration (PUT), or updates an existing one (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection configuration. connectionEnvelope is details of the hybrid
+// connection configuration.
+func (client AppsClient) CreateOrUpdateRelayServiceConnection(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnection")
+ }
+
+ req, err := client.CreateOrUpdateRelayServiceConnectionPreparer(resourceGroupName, name, entityName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateRelayServiceConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateRelayServiceConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateRelayServiceConnectionPreparer prepares the CreateOrUpdateRelayServiceConnection request.
+func (client AppsClient) CreateOrUpdateRelayServiceConnectionPreparer(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateRelayServiceConnectionSender sends the CreateOrUpdateRelayServiceConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateRelayServiceConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateRelayServiceConnectionResponder handles the response to the CreateOrUpdateRelayServiceConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateRelayServiceConnectionResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateRelayServiceConnectionSlot creates a new hybrid connection
+// configuration (PUT), or updates an existing one (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection configuration. connectionEnvelope is details of the hybrid
+// connection configuration. slot is name of the deployment slot. If a slot is
+// not specified, the API will create or update a hybrid connection for the
+// production slot.
+func (client AppsClient) CreateOrUpdateRelayServiceConnectionSlot(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity, slot string) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnectionSlot")
+ }
+
+ req, err := client.CreateOrUpdateRelayServiceConnectionSlotPreparer(resourceGroupName, name, entityName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateRelayServiceConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateRelayServiceConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateRelayServiceConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateRelayServiceConnectionSlotPreparer prepares the CreateOrUpdateRelayServiceConnectionSlot request.
+func (client AppsClient) CreateOrUpdateRelayServiceConnectionSlotPreparer(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateRelayServiceConnectionSlotSender sends the CreateOrUpdateRelayServiceConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateRelayServiceConnectionSlotResponder handles the response to the CreateOrUpdateRelayServiceConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateRelayServiceConnectionSlotResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateSlot creates a new web, mobile, or API app in an existing
+// resource group, or updates an existing app. This method may poll for
+// completion. Polling can be canceled by passing the cancel channel argument.
+// The channel will be used to cancel polling and any outstanding HTTP
+// requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is unique name of the app to create or update. To create or
+// update a deployment slot, use the {slot} parameter. siteEnvelope is a JSON
+// representation of the app properties. See example. slot is name of the
+// deployment slot to create or update. By default, this API attempts to create
+// or modify the production slot. skipDNSRegistration is if true web app
+// hostname is not registered with DNS on creation. This parameter is
+// only used for app creation skipCustomDomainVerification is if true, custom
+// (non *.azurewebsites.net) domains associated with web app are not verified.
+// forceDNSRegistration is if true, web app hostname is force registered with
+// DNS TTLInSeconds is time to live in seconds for web app's default domain
+// name
+func (client AppsClient) CreateOrUpdateSlot(resourceGroupName string, name string, siteEnvelope Site, slot string, skipDNSRegistration *bool, skipCustomDomainVerification *bool, forceDNSRegistration *bool, TTLInSeconds string, cancel <-chan struct{}) (<-chan Site, <-chan error) {
+ resultChan := make(chan Site, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: siteEnvelope,
+ Constraints: []validation.Constraint{{Target: "siteEnvelope.SiteProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.SiteConfig", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.SiteConfig.Push", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.SiteConfig.Push.IsPushEnabled", Name: validation.Null, Rule: true, Chain: nil}}},
+ }},
+ {Target: "siteEnvelope.SiteProperties.CloningInfo", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteEnvelope.SiteProperties.CloningInfo.SourceWebAppID", Name: validation.Null, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateSlot")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result Site
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdateSlotPreparer(resourceGroupName, name, siteEnvelope, slot, skipDNSRegistration, skipCustomDomainVerification, forceDNSRegistration, TTLInSeconds, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSlot", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdateSlotPreparer prepares the CreateOrUpdateSlot request.
+func (client AppsClient) CreateOrUpdateSlotPreparer(resourceGroupName string, name string, siteEnvelope Site, slot string, skipDNSRegistration *bool, skipCustomDomainVerification *bool, forceDNSRegistration *bool, TTLInSeconds string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if skipDNSRegistration != nil {
+ queryParameters["skipDnsRegistration"] = autorest.Encode("query", *skipDNSRegistration)
+ }
+ if skipCustomDomainVerification != nil {
+ queryParameters["skipCustomDomainVerification"] = autorest.Encode("query", *skipCustomDomainVerification)
+ }
+ if forceDNSRegistration != nil {
+ queryParameters["forceDnsRegistration"] = autorest.Encode("query", *forceDNSRegistration)
+ }
+ if len(TTLInSeconds) > 0 {
+ queryParameters["ttlInSeconds"] = autorest.Encode("query", TTLInSeconds)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}", pathParameters),
+ autorest.WithJSON(siteEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSlotSender sends the CreateOrUpdateSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateSlotResponder handles the response to the CreateOrUpdateSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateSlotResponder(resp *http.Response) (result Site, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateSourceControl updates the source control configuration of an
+// app. This method may poll for completion. Polling can be canceled by passing
+// the cancel channel argument. The channel will be used to cancel polling and
+// any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteSourceControl is jSON representation
+// of a SiteSourceControl object. See example.
+func (client AppsClient) CreateOrUpdateSourceControl(resourceGroupName string, name string, siteSourceControl SiteSourceControl, cancel <-chan struct{}) (<-chan SiteSourceControl, <-chan error) {
+ resultChan := make(chan SiteSourceControl, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateSourceControl")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result SiteSourceControl
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdateSourceControlPreparer(resourceGroupName, name, siteSourceControl, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSourceControl", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSourceControlSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSourceControl", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSourceControlResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSourceControl", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdateSourceControlPreparer prepares the CreateOrUpdateSourceControl request.
+func (client AppsClient) CreateOrUpdateSourceControlPreparer(resourceGroupName string, name string, siteSourceControl SiteSourceControl, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/sourcecontrols/web", pathParameters),
+ autorest.WithJSON(siteSourceControl),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSourceControlSender sends the CreateOrUpdateSourceControl request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateSourceControlSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateSourceControlResponder handles the response to the CreateOrUpdateSourceControl request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateSourceControlResponder(resp *http.Response) (result SiteSourceControl, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateSourceControlSlot updates the source control configuration of
+// an app. This method may poll for completion. Polling can be canceled by
+// passing the cancel channel argument. The channel will be used to cancel
+// polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteSourceControl is jSON representation
+// of a SiteSourceControl object. See example. slot is name of the deployment
+// slot. If a slot is not specified, the API will update the source control
+// configuration for the production slot.
+func (client AppsClient) CreateOrUpdateSourceControlSlot(resourceGroupName string, name string, siteSourceControl SiteSourceControl, slot string, cancel <-chan struct{}) (<-chan SiteSourceControl, <-chan error) {
+ resultChan := make(chan SiteSourceControl, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateSourceControlSlot")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result SiteSourceControl
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdateSourceControlSlotPreparer(resourceGroupName, name, siteSourceControl, slot, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSourceControlSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSourceControlSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSourceControlSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSourceControlSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateSourceControlSlot", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdateSourceControlSlotPreparer prepares the CreateOrUpdateSourceControlSlot request.
+func (client AppsClient) CreateOrUpdateSourceControlSlotPreparer(resourceGroupName string, name string, siteSourceControl SiteSourceControl, slot string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/sourcecontrols/web", pathParameters),
+ autorest.WithJSON(siteSourceControl),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSourceControlSlotSender sends the CreateOrUpdateSourceControlSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateSourceControlSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateSourceControlSlotResponder handles the response to the CreateOrUpdateSourceControlSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateSourceControlSlotResponder(resp *http.Response) (result SiteSourceControl, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateVnetConnection adds a Virtual Network connection to an app or
+// slot (PUT) or updates the connection properties (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of an existing Virtual
+// Network. connectionEnvelope is properties of the Virtual Network connection.
+// See example.
+func (client AppsClient) CreateOrUpdateVnetConnection(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo) (result VnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateVnetConnection")
+ }
+
+ req, err := client.CreateOrUpdateVnetConnectionPreparer(resourceGroupName, name, vnetName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateVnetConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateVnetConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateVnetConnectionPreparer prepares the CreateOrUpdateVnetConnection request.
+func (client AppsClient) CreateOrUpdateVnetConnectionPreparer(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateVnetConnectionSender sends the CreateOrUpdateVnetConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateVnetConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateVnetConnectionResponder handles the response to the CreateOrUpdateVnetConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateVnetConnectionResponder(resp *http.Response) (result VnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateVnetConnectionGateway adds a gateway to a connected Virtual
+// Network (PUT) or updates it (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the Virtual Network.
+// gatewayName is name of the gateway. Currently, the only supported string is
+// "primary". connectionEnvelope is the properties to update this gateway with.
+func (client AppsClient) CreateOrUpdateVnetConnectionGateway(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGateway")
+ }
+
+ req, err := client.CreateOrUpdateVnetConnectionGatewayPreparer(resourceGroupName, name, vnetName, gatewayName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGateway", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateVnetConnectionGatewaySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGateway", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateVnetConnectionGatewayResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGateway", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateVnetConnectionGatewayPreparer prepares the CreateOrUpdateVnetConnectionGateway request.
+func (client AppsClient) CreateOrUpdateVnetConnectionGatewayPreparer(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateVnetConnectionGatewaySender sends the CreateOrUpdateVnetConnectionGateway request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateVnetConnectionGatewayResponder handles the response to the CreateOrUpdateVnetConnectionGateway request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateVnetConnectionGatewayResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateVnetConnectionGatewaySlot adds a gateway to a connected
+// Virtual Network (PUT) or updates it (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the Virtual Network.
+// gatewayName is name of the gateway. Currently, the only supported string is
+// "primary". connectionEnvelope is the properties to update this gateway with.
+// slot is name of the deployment slot. If a slot is not specified, the API
+// will add or update a gateway for the production slot's Virtual Network.
+func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySlot(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway, slot string) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGatewaySlot")
+ }
+
+ req, err := client.CreateOrUpdateVnetConnectionGatewaySlotPreparer(resourceGroupName, name, vnetName, gatewayName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGatewaySlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateVnetConnectionGatewaySlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGatewaySlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateVnetConnectionGatewaySlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionGatewaySlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateVnetConnectionGatewaySlotPreparer prepares the CreateOrUpdateVnetConnectionGatewaySlot request.
+func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySlotPreparer(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateVnetConnectionGatewaySlotSender sends the CreateOrUpdateVnetConnectionGatewaySlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateVnetConnectionGatewaySlotResponder handles the response to the CreateOrUpdateVnetConnectionGatewaySlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateVnetConnectionGatewaySlotResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateVnetConnectionSlot adds a Virtual Network connection to an app
+// or slot (PUT) or updates the connection properties (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of an existing Virtual
+// Network. connectionEnvelope is properties of the Virtual Network connection.
+// See example. slot is name of the deployment slot. If a slot is not
+// specified, the API will add or update connections for the production slot.
+func (client AppsClient) CreateOrUpdateVnetConnectionSlot(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo, slot string) (result VnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionSlot")
+ }
+
+ req, err := client.CreateOrUpdateVnetConnectionSlotPreparer(resourceGroupName, name, vnetName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateVnetConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateVnetConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "CreateOrUpdateVnetConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateVnetConnectionSlotPreparer prepares the CreateOrUpdateVnetConnectionSlot request.
+func (client AppsClient) CreateOrUpdateVnetConnectionSlotPreparer(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateVnetConnectionSlotSender sends the CreateOrUpdateVnetConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) CreateOrUpdateVnetConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateVnetConnectionSlotResponder handles the response to the CreateOrUpdateVnetConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) CreateOrUpdateVnetConnectionSlotResponder(resp *http.Response) (result VnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete deletes a web, mobile, or API app, or one of the deployment slots.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app to delete. deleteMetrics is if true, web
+// app metrics are also deleted deleteEmptyServerFarm is specify true if the
+// App Service plan will be empty after app deletion and you want to delete the
+// empty App Service plan. By default, the empty App Service plan is not
+// deleted. skipDNSRegistration is if true, DNS registration is skipped
+func (client AppsClient) Delete(resourceGroupName string, name string, deleteMetrics *bool, deleteEmptyServerFarm *bool, skipDNSRegistration *bool) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "Delete")
+ }
+
+ req, err := client.DeletePreparer(resourceGroupName, name, deleteMetrics, deleteEmptyServerFarm, skipDNSRegistration)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Delete", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client AppsClient) DeletePreparer(resourceGroupName string, name string, deleteMetrics *bool, deleteEmptyServerFarm *bool, skipDNSRegistration *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if deleteMetrics != nil {
+ queryParameters["deleteMetrics"] = autorest.Encode("query", *deleteMetrics)
+ }
+ if deleteEmptyServerFarm != nil {
+ queryParameters["deleteEmptyServerFarm"] = autorest.Encode("query", *deleteEmptyServerFarm)
+ }
+ if skipDNSRegistration != nil {
+ queryParameters["skipDnsRegistration"] = autorest.Encode("query", *skipDNSRegistration)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteBackup deletes a backup of an app by its ID.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. backupID is iD of the backup.
+func (client AppsClient) DeleteBackup(resourceGroupName string, name string, backupID string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteBackup")
+ }
+
+ req, err := client.DeleteBackupPreparer(resourceGroupName, name, backupID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteBackupSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteBackupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteBackupPreparer prepares the DeleteBackup request.
+func (client AppsClient) DeleteBackupPreparer(resourceGroupName string, name string, backupID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/backups/{backupId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteBackupSender sends the DeleteBackup request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteBackupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteBackupResponder handles the response to the DeleteBackup request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteBackupResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteBackupConfiguration deletes the backup configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) DeleteBackupConfiguration(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteBackupConfiguration")
+ }
+
+ req, err := client.DeleteBackupConfigurationPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteBackupConfigurationSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteBackupConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupConfiguration", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteBackupConfigurationPreparer prepares the DeleteBackupConfiguration request.
+func (client AppsClient) DeleteBackupConfigurationPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/backup", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteBackupConfigurationSender sends the DeleteBackupConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteBackupConfigurationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteBackupConfigurationResponder handles the response to the DeleteBackupConfiguration request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteBackupConfigurationResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteBackupConfigurationSlot deletes the backup configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will delete the backup configuration for the
+// production slot.
+func (client AppsClient) DeleteBackupConfigurationSlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteBackupConfigurationSlot")
+ }
+
+ req, err := client.DeleteBackupConfigurationSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteBackupConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteBackupConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteBackupConfigurationSlotPreparer prepares the DeleteBackupConfigurationSlot request.
+func (client AppsClient) DeleteBackupConfigurationSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/backup", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteBackupConfigurationSlotSender sends the DeleteBackupConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteBackupConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteBackupConfigurationSlotResponder handles the response to the DeleteBackupConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteBackupConfigurationSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteBackupSlot deletes a backup of an app by its ID.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. backupID is iD of the backup. slot is name
+// of the deployment slot. If a slot is not specified, the API will delete a
+// backup of the production slot.
+func (client AppsClient) DeleteBackupSlot(resourceGroupName string, name string, backupID string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteBackupSlot")
+ }
+
+ req, err := client.DeleteBackupSlotPreparer(resourceGroupName, name, backupID, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteBackupSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteBackupSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteBackupSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteBackupSlotPreparer prepares the DeleteBackupSlot request.
+func (client AppsClient) DeleteBackupSlotPreparer(resourceGroupName string, name string, backupID string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/backups/{backupId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteBackupSlotSender sends the DeleteBackupSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteBackupSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteBackupSlotResponder handles the response to the DeleteBackupSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteBackupSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteDeployment delete a deployment by its ID for an app, a specific
+// deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID.
+func (client AppsClient) DeleteDeployment(resourceGroupName string, name string, ID string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteDeployment")
+ }
+
+ req, err := client.DeleteDeploymentPreparer(resourceGroupName, name, ID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDeployment", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteDeploymentSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDeployment", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteDeploymentResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDeployment", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteDeploymentPreparer prepares the DeleteDeployment request.
+func (client AppsClient) DeleteDeploymentPreparer(resourceGroupName string, name string, ID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteDeploymentSender sends the DeleteDeployment request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteDeploymentSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteDeploymentResponder handles the response to the DeleteDeployment request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteDeploymentResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteDeploymentSlot delete a deployment by its ID for an app, a specific
+// deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID. slot is name of the
+// deployment slot. If a slot is not specified, the API deletes a deployment
+// for the production slot.
+func (client AppsClient) DeleteDeploymentSlot(resourceGroupName string, name string, ID string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteDeploymentSlot")
+ }
+
+ req, err := client.DeleteDeploymentSlotPreparer(resourceGroupName, name, ID, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDeploymentSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteDeploymentSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDeploymentSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteDeploymentSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDeploymentSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteDeploymentSlotPreparer prepares the DeleteDeploymentSlot request.
+func (client AppsClient) DeleteDeploymentSlotPreparer(resourceGroupName string, name string, ID string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteDeploymentSlotSender sends the DeleteDeploymentSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteDeploymentSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteDeploymentSlotResponder handles the response to the DeleteDeploymentSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteDeploymentSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteDomainOwnershipIdentifier deletes a domain ownership identifier for a
+// web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier.
+func (client AppsClient) DeleteDomainOwnershipIdentifier(resourceGroupName string, name string, domainOwnershipIdentifierName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifier")
+ }
+
+ req, err := client.DeleteDomainOwnershipIdentifierPreparer(resourceGroupName, name, domainOwnershipIdentifierName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteDomainOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteDomainOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteDomainOwnershipIdentifierPreparer prepares the DeleteDomainOwnershipIdentifier request.
+func (client AppsClient) DeleteDomainOwnershipIdentifierPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteDomainOwnershipIdentifierSender sends the DeleteDomainOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteDomainOwnershipIdentifierResponder handles the response to the DeleteDomainOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteDomainOwnershipIdentifierResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteDomainOwnershipIdentifierSlot deletes a domain ownership identifier
+// for a web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier. slot is name of the deployment slot. If a slot
+// is not specified, the API will delete the binding for the production slot.
+func (client AppsClient) DeleteDomainOwnershipIdentifierSlot(resourceGroupName string, name string, domainOwnershipIdentifierName string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifierSlot")
+ }
+
+ req, err := client.DeleteDomainOwnershipIdentifierSlotPreparer(resourceGroupName, name, domainOwnershipIdentifierName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifierSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteDomainOwnershipIdentifierSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifierSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteDomainOwnershipIdentifierSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteDomainOwnershipIdentifierSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteDomainOwnershipIdentifierSlotPreparer prepares the DeleteDomainOwnershipIdentifierSlot request.
+func (client AppsClient) DeleteDomainOwnershipIdentifierSlotPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteDomainOwnershipIdentifierSlotSender sends the DeleteDomainOwnershipIdentifierSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteDomainOwnershipIdentifierSlotResponder handles the response to the DeleteDomainOwnershipIdentifierSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteDomainOwnershipIdentifierSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteHostNameBinding deletes a hostname binding for an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. hostName is hostname in the hostname
+// binding.
+func (client AppsClient) DeleteHostNameBinding(resourceGroupName string, name string, hostName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteHostNameBinding")
+ }
+
+ req, err := client.DeleteHostNameBindingPreparer(resourceGroupName, name, hostName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHostNameBinding", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteHostNameBindingSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHostNameBinding", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteHostNameBindingResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHostNameBinding", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteHostNameBindingPreparer prepares the DeleteHostNameBinding request.
+func (client AppsClient) DeleteHostNameBindingPreparer(resourceGroupName string, name string, hostName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hostName": autorest.Encode("path", hostName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hostNameBindings/{hostName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteHostNameBindingSender sends the DeleteHostNameBinding request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteHostNameBindingSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteHostNameBindingResponder handles the response to the DeleteHostNameBinding request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteHostNameBindingResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteHostNameBindingSlot deletes a hostname binding for an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will delete the binding for the production
+// slot. hostName is hostname in the hostname binding.
+func (client AppsClient) DeleteHostNameBindingSlot(resourceGroupName string, name string, slot string, hostName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteHostNameBindingSlot")
+ }
+
+ req, err := client.DeleteHostNameBindingSlotPreparer(resourceGroupName, name, slot, hostName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHostNameBindingSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteHostNameBindingSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHostNameBindingSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteHostNameBindingSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHostNameBindingSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteHostNameBindingSlotPreparer prepares the DeleteHostNameBindingSlot request.
+func (client AppsClient) DeleteHostNameBindingSlotPreparer(resourceGroupName string, name string, slot string, hostName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hostName": autorest.Encode("path", hostName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hostNameBindings/{hostName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteHostNameBindingSlotSender sends the DeleteHostNameBindingSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteHostNameBindingSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteHostNameBindingSlotResponder handles the response to the DeleteHostNameBindingSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteHostNameBindingSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteHybridConnection removes a Hybrid Connection from this site.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection
+func (client AppsClient) DeleteHybridConnection(resourceGroupName string, name string, namespaceName string, relayName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteHybridConnection")
+ }
+
+ req, err := client.DeleteHybridConnectionPreparer(resourceGroupName, name, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHybridConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteHybridConnectionSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHybridConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHybridConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteHybridConnectionPreparer prepares the DeleteHybridConnection request.
+func (client AppsClient) DeleteHybridConnectionPreparer(resourceGroupName string, name string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteHybridConnectionSender sends the DeleteHybridConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteHybridConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteHybridConnectionResponder handles the response to the DeleteHybridConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteHybridConnectionResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteHybridConnectionSlot removes a Hybrid Connection from this site.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection slot is the name of the slot for the web app.
+func (client AppsClient) DeleteHybridConnectionSlot(resourceGroupName string, name string, namespaceName string, relayName string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteHybridConnectionSlot")
+ }
+
+ req, err := client.DeleteHybridConnectionSlotPreparer(resourceGroupName, name, namespaceName, relayName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHybridConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteHybridConnectionSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHybridConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteHybridConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteHybridConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteHybridConnectionSlotPreparer prepares the DeleteHybridConnectionSlot request.
+func (client AppsClient) DeleteHybridConnectionSlotPreparer(resourceGroupName string, name string, namespaceName string, relayName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteHybridConnectionSlotSender sends the DeleteHybridConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteHybridConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteHybridConnectionSlotResponder handles the response to the DeleteHybridConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteHybridConnectionSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteInstanceDeployment delete a deployment by its ID for an app, a
+// specific deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID. instanceID is iD of a
+// specific scaled-out instance. This is the value of the name property in the
+// JSON response from "GET api/sites/{siteName}/instances"
+func (client AppsClient) DeleteInstanceDeployment(resourceGroupName string, name string, ID string, instanceID string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteInstanceDeployment")
+ }
+
+ req, err := client.DeleteInstanceDeploymentPreparer(resourceGroupName, name, ID, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteInstanceDeployment", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteInstanceDeploymentSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteInstanceDeployment", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteInstanceDeploymentResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteInstanceDeployment", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteInstanceDeploymentPreparer prepares the DeleteInstanceDeployment request.
+func (client AppsClient) DeleteInstanceDeploymentPreparer(resourceGroupName string, name string, ID string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/instances/{instanceId}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteInstanceDeploymentSender sends the DeleteInstanceDeployment request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteInstanceDeploymentSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteInstanceDeploymentResponder handles the response to the DeleteInstanceDeployment request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteInstanceDeploymentResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteInstanceDeploymentSlot delete a deployment by its ID for an app, a
+// specific deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID. slot is name of the
+// deployment slot. If a slot is not specified, the API deletes a deployment
+// for the production slot. instanceID is iD of a specific scaled-out instance.
+// This is the value of the name property in the JSON response from "GET
+// api/sites/{siteName}/instances"
+func (client AppsClient) DeleteInstanceDeploymentSlot(resourceGroupName string, name string, ID string, slot string, instanceID string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteInstanceDeploymentSlot")
+ }
+
+ req, err := client.DeleteInstanceDeploymentSlotPreparer(resourceGroupName, name, ID, slot, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteInstanceDeploymentSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteInstanceDeploymentSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteInstanceDeploymentSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteInstanceDeploymentSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteInstanceDeploymentSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteInstanceDeploymentSlotPreparer prepares the DeleteInstanceDeploymentSlot request.
+func (client AppsClient) DeleteInstanceDeploymentSlotPreparer(resourceGroupName string, name string, ID string, slot string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/instances/{instanceId}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteInstanceDeploymentSlotSender sends the DeleteInstanceDeploymentSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteInstanceDeploymentSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteInstanceDeploymentSlotResponder handles the response to the DeleteInstanceDeploymentSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteInstanceDeploymentSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeletePremierAddOn delete a premier add-on from an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. premierAddOnName is add-on name.
+func (client AppsClient) DeletePremierAddOn(resourceGroupName string, name string, premierAddOnName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeletePremierAddOn")
+ }
+
+ req, err := client.DeletePremierAddOnPreparer(resourceGroupName, name, premierAddOnName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeletePremierAddOn", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeletePremierAddOnSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeletePremierAddOn", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeletePremierAddOnResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeletePremierAddOn", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePremierAddOnPreparer prepares the DeletePremierAddOn request.
+func (client AppsClient) DeletePremierAddOnPreparer(resourceGroupName string, name string, premierAddOnName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "premierAddOnName": autorest.Encode("path", premierAddOnName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/premieraddons/{premierAddOnName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeletePremierAddOnSender sends the DeletePremierAddOn request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeletePremierAddOnSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeletePremierAddOnResponder handles the response to the DeletePremierAddOn request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeletePremierAddOnResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeletePremierAddOnSlot delete a premier add-on from an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. premierAddOnName is add-on name. slot is
+// name of the deployment slot. If a slot is not specified, the API will delete
+// the named add-on for the production slot.
+func (client AppsClient) DeletePremierAddOnSlot(resourceGroupName string, name string, premierAddOnName string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeletePremierAddOnSlot")
+ }
+
+ req, err := client.DeletePremierAddOnSlotPreparer(resourceGroupName, name, premierAddOnName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeletePremierAddOnSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeletePremierAddOnSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeletePremierAddOnSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeletePremierAddOnSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeletePremierAddOnSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePremierAddOnSlotPreparer prepares the DeletePremierAddOnSlot request.
+func (client AppsClient) DeletePremierAddOnSlotPreparer(resourceGroupName string, name string, premierAddOnName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "premierAddOnName": autorest.Encode("path", premierAddOnName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/premieraddons/{premierAddOnName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeletePremierAddOnSlotSender sends the DeletePremierAddOnSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeletePremierAddOnSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeletePremierAddOnSlotResponder handles the response to the DeletePremierAddOnSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeletePremierAddOnSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteRelayServiceConnection deletes a relay service connection by its name.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection configuration.
+func (client AppsClient) DeleteRelayServiceConnection(resourceGroupName string, name string, entityName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteRelayServiceConnection")
+ }
+
+ req, err := client.DeleteRelayServiceConnectionPreparer(resourceGroupName, name, entityName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteRelayServiceConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteRelayServiceConnectionSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteRelayServiceConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteRelayServiceConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteRelayServiceConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteRelayServiceConnectionPreparer prepares the DeleteRelayServiceConnection request.
+func (client AppsClient) DeleteRelayServiceConnectionPreparer(resourceGroupName string, name string, entityName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteRelayServiceConnectionSender sends the DeleteRelayServiceConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteRelayServiceConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteRelayServiceConnectionResponder handles the response to the DeleteRelayServiceConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteRelayServiceConnectionResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteRelayServiceConnectionSlot deletes a relay service connection by its
+// name.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection configuration. slot is name of the deployment slot. If a slot is
+// not specified, the API will delete a hybrid connection for the production
+// slot.
+func (client AppsClient) DeleteRelayServiceConnectionSlot(resourceGroupName string, name string, entityName string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteRelayServiceConnectionSlot")
+ }
+
+ req, err := client.DeleteRelayServiceConnectionSlotPreparer(resourceGroupName, name, entityName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteRelayServiceConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteRelayServiceConnectionSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteRelayServiceConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteRelayServiceConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteRelayServiceConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteRelayServiceConnectionSlotPreparer prepares the DeleteRelayServiceConnectionSlot request.
+func (client AppsClient) DeleteRelayServiceConnectionSlotPreparer(resourceGroupName string, name string, entityName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteRelayServiceConnectionSlotSender sends the DeleteRelayServiceConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteRelayServiceConnectionSlotResponder handles the response to the DeleteRelayServiceConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteRelayServiceConnectionSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteSlot deletes a web, mobile, or API app, or one of the deployment
+// slots.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app to delete. slot is name of the deployment
+// slot to delete. By default, the API deletes the production slot.
+// deleteMetrics is if true, web app metrics are also deleted
+// deleteEmptyServerFarm is specify true if the App Service plan will be empty
+// after app deletion and you want to delete the empty App Service plan. By
+// default, the empty App Service plan is not deleted. skipDNSRegistration is
+// if true, DNS registration is skipped
+func (client AppsClient) DeleteSlot(resourceGroupName string, name string, slot string, deleteMetrics *bool, deleteEmptyServerFarm *bool, skipDNSRegistration *bool) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteSlot")
+ }
+
+ req, err := client.DeleteSlotPreparer(resourceGroupName, name, slot, deleteMetrics, deleteEmptyServerFarm, skipDNSRegistration)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteSlotPreparer prepares the DeleteSlot request.
+func (client AppsClient) DeleteSlotPreparer(resourceGroupName string, name string, slot string, deleteMetrics *bool, deleteEmptyServerFarm *bool, skipDNSRegistration *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if deleteMetrics != nil {
+ queryParameters["deleteMetrics"] = autorest.Encode("query", *deleteMetrics)
+ }
+ if deleteEmptyServerFarm != nil {
+ queryParameters["deleteEmptyServerFarm"] = autorest.Encode("query", *deleteEmptyServerFarm)
+ }
+ if skipDNSRegistration != nil {
+ queryParameters["skipDnsRegistration"] = autorest.Encode("query", *skipDNSRegistration)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSlotSender sends the DeleteSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteSlotResponder handles the response to the DeleteSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteSourceControl deletes the source control configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) DeleteSourceControl(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteSourceControl")
+ }
+
+ req, err := client.DeleteSourceControlPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSourceControl", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSourceControlSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSourceControl", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteSourceControlResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSourceControl", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteSourceControlPreparer prepares the DeleteSourceControl request.
+func (client AppsClient) DeleteSourceControlPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/sourcecontrols/web", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSourceControlSender sends the DeleteSourceControl request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteSourceControlSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteSourceControlResponder handles the response to the DeleteSourceControl request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteSourceControlResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteSourceControlSlot deletes the source control configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will delete the source control configuration
+// for the production slot.
+func (client AppsClient) DeleteSourceControlSlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteSourceControlSlot")
+ }
+
+ req, err := client.DeleteSourceControlSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSourceControlSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSourceControlSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSourceControlSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteSourceControlSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteSourceControlSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteSourceControlSlotPreparer prepares the DeleteSourceControlSlot request.
+func (client AppsClient) DeleteSourceControlSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/sourcecontrols/web", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSourceControlSlotSender sends the DeleteSourceControlSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteSourceControlSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteSourceControlSlotResponder handles the response to the DeleteSourceControlSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteSourceControlSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteVnetConnection deletes a connection from an app (or deployment slot to
+// a named virtual network.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the virtual network.
+func (client AppsClient) DeleteVnetConnection(resourceGroupName string, name string, vnetName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteVnetConnection")
+ }
+
+ req, err := client.DeleteVnetConnectionPreparer(resourceGroupName, name, vnetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteVnetConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteVnetConnectionSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteVnetConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteVnetConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteVnetConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteVnetConnectionPreparer prepares the DeleteVnetConnection request.
+func (client AppsClient) DeleteVnetConnectionPreparer(resourceGroupName string, name string, vnetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteVnetConnectionSender sends the DeleteVnetConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteVnetConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteVnetConnectionResponder handles the response to the DeleteVnetConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteVnetConnectionResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteVnetConnectionSlot deletes a connection from an app (or deployment
+// slot to a named virtual network.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the virtual network.
+// slot is name of the deployment slot. If a slot is not specified, the API
+// will delete the connection for the production slot.
+func (client AppsClient) DeleteVnetConnectionSlot(resourceGroupName string, name string, vnetName string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DeleteVnetConnectionSlot")
+ }
+
+ req, err := client.DeleteVnetConnectionSlotPreparer(resourceGroupName, name, vnetName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteVnetConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteVnetConnectionSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteVnetConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteVnetConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DeleteVnetConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteVnetConnectionSlotPreparer prepares the DeleteVnetConnectionSlot request.
+func (client AppsClient) DeleteVnetConnectionSlotPreparer(resourceGroupName string, name string, vnetName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteVnetConnectionSlotSender sends the DeleteVnetConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DeleteVnetConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteVnetConnectionSlotResponder handles the response to the DeleteVnetConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DeleteVnetConnectionSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DiscoverRestore discovers an existing app backup that can be restored from a
+// blob in Azure storage.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. request is a RestoreRequest object that
+// includes Azure storage URL and blog name for discovery of backup.
+func (client AppsClient) DiscoverRestore(resourceGroupName string, name string, request RestoreRequest) (result RestoreRequest, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DiscoverRestore")
+ }
+
+ req, err := client.DiscoverRestorePreparer(resourceGroupName, name, request)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DiscoverRestore", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DiscoverRestoreSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DiscoverRestore", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DiscoverRestoreResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DiscoverRestore", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DiscoverRestorePreparer prepares the DiscoverRestore request.
+func (client AppsClient) DiscoverRestorePreparer(resourceGroupName string, name string, request RestoreRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/backups/discover", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DiscoverRestoreSender sends the DiscoverRestore request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DiscoverRestoreSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DiscoverRestoreResponder handles the response to the DiscoverRestore request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DiscoverRestoreResponder(resp *http.Response) (result RestoreRequest, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// DiscoverRestoreSlot discovers an existing app backup that can be restored
+// from a blob in Azure storage.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. request is a RestoreRequest object that
+// includes Azure storage URL and blog name for discovery of backup. slot is
+// name of the deployment slot. If a slot is not specified, the API will
+// perform discovery for the production slot.
+func (client AppsClient) DiscoverRestoreSlot(resourceGroupName string, name string, request RestoreRequest, slot string) (result RestoreRequest, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "DiscoverRestoreSlot")
+ }
+
+ req, err := client.DiscoverRestoreSlotPreparer(resourceGroupName, name, request, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DiscoverRestoreSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DiscoverRestoreSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DiscoverRestoreSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DiscoverRestoreSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "DiscoverRestoreSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DiscoverRestoreSlotPreparer prepares the DiscoverRestoreSlot request.
+func (client AppsClient) DiscoverRestoreSlotPreparer(resourceGroupName string, name string, request RestoreRequest, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/backups/discover", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DiscoverRestoreSlotSender sends the DiscoverRestoreSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) DiscoverRestoreSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DiscoverRestoreSlotResponder handles the response to the DiscoverRestoreSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) DiscoverRestoreSlotResponder(resp *http.Response) (result RestoreRequest, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GenerateNewSitePublishingPassword generates a new publishing password for an
+// app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) GenerateNewSitePublishingPassword(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GenerateNewSitePublishingPassword")
+ }
+
+ req, err := client.GenerateNewSitePublishingPasswordPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GenerateNewSitePublishingPassword", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GenerateNewSitePublishingPasswordSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GenerateNewSitePublishingPassword", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GenerateNewSitePublishingPasswordResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GenerateNewSitePublishingPassword", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GenerateNewSitePublishingPasswordPreparer prepares the GenerateNewSitePublishingPassword request.
+func (client AppsClient) GenerateNewSitePublishingPasswordPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/newpassword", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GenerateNewSitePublishingPasswordSender sends the GenerateNewSitePublishingPassword request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GenerateNewSitePublishingPasswordSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GenerateNewSitePublishingPasswordResponder handles the response to the GenerateNewSitePublishingPassword request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GenerateNewSitePublishingPasswordResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// GenerateNewSitePublishingPasswordSlot generates a new publishing password
+// for an app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API generate a new publishing password for the
+// production slot.
+func (client AppsClient) GenerateNewSitePublishingPasswordSlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GenerateNewSitePublishingPasswordSlot")
+ }
+
+ req, err := client.GenerateNewSitePublishingPasswordSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GenerateNewSitePublishingPasswordSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GenerateNewSitePublishingPasswordSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GenerateNewSitePublishingPasswordSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GenerateNewSitePublishingPasswordSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GenerateNewSitePublishingPasswordSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GenerateNewSitePublishingPasswordSlotPreparer prepares the GenerateNewSitePublishingPasswordSlot request.
+func (client AppsClient) GenerateNewSitePublishingPasswordSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/newpassword", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GenerateNewSitePublishingPasswordSlotSender sends the GenerateNewSitePublishingPasswordSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GenerateNewSitePublishingPasswordSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GenerateNewSitePublishingPasswordSlotResponder handles the response to the GenerateNewSitePublishingPasswordSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GenerateNewSitePublishingPasswordSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get gets the details of a web, mobile, or API app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) Get(resourceGroupName string, name string) (result Site, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "Get")
+ }
+
+ req, err := client.GetPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client AppsClient) GetPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetResponder(resp *http.Response) (result Site, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetAuthSettings gets the Authentication/Authorization settings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) GetAuthSettings(resourceGroupName string, name string) (result SiteAuthSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetAuthSettings")
+ }
+
+ req, err := client.GetAuthSettingsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetAuthSettings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetAuthSettingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetAuthSettings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetAuthSettingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetAuthSettings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetAuthSettingsPreparer prepares the GetAuthSettings request.
+func (client AppsClient) GetAuthSettingsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/authsettings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetAuthSettingsSender sends the GetAuthSettings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetAuthSettingsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetAuthSettingsResponder handles the response to the GetAuthSettings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetAuthSettingsResponder(resp *http.Response) (result SiteAuthSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetAuthSettingsSlot gets the Authentication/Authorization settings of an
+// app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the settings for the production
+// slot.
+func (client AppsClient) GetAuthSettingsSlot(resourceGroupName string, name string, slot string) (result SiteAuthSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetAuthSettingsSlot")
+ }
+
+ req, err := client.GetAuthSettingsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetAuthSettingsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetAuthSettingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetAuthSettingsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetAuthSettingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetAuthSettingsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetAuthSettingsSlotPreparer prepares the GetAuthSettingsSlot request.
+func (client AppsClient) GetAuthSettingsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/authsettings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetAuthSettingsSlotSender sends the GetAuthSettingsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetAuthSettingsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetAuthSettingsSlotResponder handles the response to the GetAuthSettingsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetAuthSettingsSlotResponder(resp *http.Response) (result SiteAuthSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetBackupConfiguration gets the backup configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) GetBackupConfiguration(resourceGroupName string, name string) (result BackupRequest, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetBackupConfiguration")
+ }
+
+ req, err := client.GetBackupConfigurationPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetBackupConfigurationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetBackupConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupConfiguration", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetBackupConfigurationPreparer prepares the GetBackupConfiguration request.
+func (client AppsClient) GetBackupConfigurationPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/backup/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetBackupConfigurationSender sends the GetBackupConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetBackupConfigurationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetBackupConfigurationResponder handles the response to the GetBackupConfiguration request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetBackupConfigurationResponder(resp *http.Response) (result BackupRequest, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetBackupConfigurationSlot gets the backup configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the backup configuration for the
+// production slot.
+func (client AppsClient) GetBackupConfigurationSlot(resourceGroupName string, name string, slot string) (result BackupRequest, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetBackupConfigurationSlot")
+ }
+
+ req, err := client.GetBackupConfigurationSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetBackupConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetBackupConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetBackupConfigurationSlotPreparer prepares the GetBackupConfigurationSlot request.
+func (client AppsClient) GetBackupConfigurationSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/backup/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetBackupConfigurationSlotSender sends the GetBackupConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetBackupConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetBackupConfigurationSlotResponder handles the response to the GetBackupConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetBackupConfigurationSlotResponder(resp *http.Response) (result BackupRequest, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetBackupStatus gets a backup of an app by its ID.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. backupID is iD of the backup.
+func (client AppsClient) GetBackupStatus(resourceGroupName string, name string, backupID string) (result BackupItem, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetBackupStatus")
+ }
+
+ req, err := client.GetBackupStatusPreparer(resourceGroupName, name, backupID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupStatus", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetBackupStatusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupStatus", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetBackupStatusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupStatus", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetBackupStatusPreparer prepares the GetBackupStatus request.
+func (client AppsClient) GetBackupStatusPreparer(resourceGroupName string, name string, backupID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/backups/{backupId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetBackupStatusSender sends the GetBackupStatus request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetBackupStatusSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetBackupStatusResponder handles the response to the GetBackupStatus request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetBackupStatusResponder(resp *http.Response) (result BackupItem, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetBackupStatusSlot gets a backup of an app by its ID.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. backupID is iD of the backup. slot is name
+// of the deployment slot. If a slot is not specified, the API will get a
+// backup of the production slot.
+func (client AppsClient) GetBackupStatusSlot(resourceGroupName string, name string, backupID string, slot string) (result BackupItem, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetBackupStatusSlot")
+ }
+
+ req, err := client.GetBackupStatusSlotPreparer(resourceGroupName, name, backupID, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupStatusSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetBackupStatusSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupStatusSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetBackupStatusSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetBackupStatusSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetBackupStatusSlotPreparer prepares the GetBackupStatusSlot request.
+func (client AppsClient) GetBackupStatusSlotPreparer(resourceGroupName string, name string, backupID string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/backups/{backupId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetBackupStatusSlotSender sends the GetBackupStatusSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetBackupStatusSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetBackupStatusSlotResponder handles the response to the GetBackupStatusSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetBackupStatusSlotResponder(resp *http.Response) (result BackupItem, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetConfiguration gets the configuration of an app, such as platform version
+// and bitness, default documents, virtual applications, Always On, etc.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) GetConfiguration(resourceGroupName string, name string) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetConfiguration")
+ }
+
+ req, err := client.GetConfigurationPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetConfigurationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfiguration", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetConfigurationPreparer prepares the GetConfiguration request.
+func (client AppsClient) GetConfigurationPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/web", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetConfigurationSender sends the GetConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetConfigurationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetConfigurationResponder handles the response to the GetConfiguration request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetConfigurationResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetConfigurationSlot gets the configuration of an app, such as platform
+// version and bitness, default documents, virtual applications, Always On,
+// etc.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will return configuration for the production
+// slot.
+func (client AppsClient) GetConfigurationSlot(resourceGroupName string, name string, slot string) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetConfigurationSlot")
+ }
+
+ req, err := client.GetConfigurationSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetConfigurationSlotPreparer prepares the GetConfigurationSlot request.
+func (client AppsClient) GetConfigurationSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/web", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetConfigurationSlotSender sends the GetConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetConfigurationSlotResponder handles the response to the GetConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetConfigurationSlotResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetConfigurationSnapshot gets a snapshot of the configuration of an app at a
+// previous point in time.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. snapshotID is the ID of the snapshot to
+// read.
+func (client AppsClient) GetConfigurationSnapshot(resourceGroupName string, name string, snapshotID string) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetConfigurationSnapshot")
+ }
+
+ req, err := client.GetConfigurationSnapshotPreparer(resourceGroupName, name, snapshotID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSnapshot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetConfigurationSnapshotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSnapshot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetConfigurationSnapshotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSnapshot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetConfigurationSnapshotPreparer prepares the GetConfigurationSnapshot request.
+func (client AppsClient) GetConfigurationSnapshotPreparer(resourceGroupName string, name string, snapshotID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotId": autorest.Encode("path", snapshotID),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/web/snapshots/{snapshotId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetConfigurationSnapshotSender sends the GetConfigurationSnapshot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetConfigurationSnapshotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetConfigurationSnapshotResponder handles the response to the GetConfigurationSnapshot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetConfigurationSnapshotResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetConfigurationSnapshotSlot gets a snapshot of the configuration of an app
+// at a previous point in time.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. snapshotID is the ID of the snapshot to
+// read. slot is name of the deployment slot. If a slot is not specified, the
+// API will return configuration for the production slot.
+func (client AppsClient) GetConfigurationSnapshotSlot(resourceGroupName string, name string, snapshotID string, slot string) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetConfigurationSnapshotSlot")
+ }
+
+ req, err := client.GetConfigurationSnapshotSlotPreparer(resourceGroupName, name, snapshotID, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSnapshotSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetConfigurationSnapshotSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSnapshotSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetConfigurationSnapshotSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetConfigurationSnapshotSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetConfigurationSnapshotSlotPreparer prepares the GetConfigurationSnapshotSlot request.
+func (client AppsClient) GetConfigurationSnapshotSlotPreparer(resourceGroupName string, name string, snapshotID string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "snapshotId": autorest.Encode("path", snapshotID),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/web/snapshots/{snapshotId}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetConfigurationSnapshotSlotSender sends the GetConfigurationSnapshotSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetConfigurationSnapshotSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetConfigurationSnapshotSlotResponder handles the response to the GetConfigurationSnapshotSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetConfigurationSnapshotSlotResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetDeployment get a deployment by its ID for an app, a specific deployment
+// slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID.
+func (client AppsClient) GetDeployment(resourceGroupName string, name string, ID string) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetDeployment")
+ }
+
+ req, err := client.GetDeploymentPreparer(resourceGroupName, name, ID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDeployment", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetDeploymentSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDeployment", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetDeploymentResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDeployment", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetDeploymentPreparer prepares the GetDeployment request.
+func (client AppsClient) GetDeploymentPreparer(resourceGroupName string, name string, ID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetDeploymentSender sends the GetDeployment request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetDeploymentSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetDeploymentResponder handles the response to the GetDeployment request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetDeploymentResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetDeploymentSlot get a deployment by its ID for an app, a specific
+// deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID. slot is name of the
+// deployment slot. If a slot is not specified, the API gets a deployment for
+// the production slot.
+func (client AppsClient) GetDeploymentSlot(resourceGroupName string, name string, ID string, slot string) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetDeploymentSlot")
+ }
+
+ req, err := client.GetDeploymentSlotPreparer(resourceGroupName, name, ID, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDeploymentSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetDeploymentSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDeploymentSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetDeploymentSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDeploymentSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetDeploymentSlotPreparer prepares the GetDeploymentSlot request.
+func (client AppsClient) GetDeploymentSlotPreparer(resourceGroupName string, name string, ID string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetDeploymentSlotSender sends the GetDeploymentSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetDeploymentSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetDeploymentSlotResponder handles the response to the GetDeploymentSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetDeploymentSlotResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetDiagnosticLogsConfiguration gets the logging configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) GetDiagnosticLogsConfiguration(resourceGroupName string, name string) (result SiteLogsConfig, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetDiagnosticLogsConfiguration")
+ }
+
+ req, err := client.GetDiagnosticLogsConfigurationPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDiagnosticLogsConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetDiagnosticLogsConfigurationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDiagnosticLogsConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetDiagnosticLogsConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDiagnosticLogsConfiguration", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetDiagnosticLogsConfigurationPreparer prepares the GetDiagnosticLogsConfiguration request.
+func (client AppsClient) GetDiagnosticLogsConfigurationPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/logs", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetDiagnosticLogsConfigurationSender sends the GetDiagnosticLogsConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetDiagnosticLogsConfigurationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetDiagnosticLogsConfigurationResponder handles the response to the GetDiagnosticLogsConfiguration request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetDiagnosticLogsConfigurationResponder(resp *http.Response) (result SiteLogsConfig, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetDiagnosticLogsConfigurationSlot gets the logging configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the logging configuration for the
+// production slot.
+func (client AppsClient) GetDiagnosticLogsConfigurationSlot(resourceGroupName string, name string, slot string) (result SiteLogsConfig, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetDiagnosticLogsConfigurationSlot")
+ }
+
+ req, err := client.GetDiagnosticLogsConfigurationSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDiagnosticLogsConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetDiagnosticLogsConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDiagnosticLogsConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetDiagnosticLogsConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDiagnosticLogsConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetDiagnosticLogsConfigurationSlotPreparer prepares the GetDiagnosticLogsConfigurationSlot request.
+func (client AppsClient) GetDiagnosticLogsConfigurationSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/logs", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetDiagnosticLogsConfigurationSlotSender sends the GetDiagnosticLogsConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetDiagnosticLogsConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetDiagnosticLogsConfigurationSlotResponder handles the response to the GetDiagnosticLogsConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetDiagnosticLogsConfigurationSlotResponder(resp *http.Response) (result SiteLogsConfig, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetDomainOwnershipIdentifier get domain ownership identifier for web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier.
+func (client AppsClient) GetDomainOwnershipIdentifier(resourceGroupName string, name string, domainOwnershipIdentifierName string) (result Identifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetDomainOwnershipIdentifier")
+ }
+
+ req, err := client.GetDomainOwnershipIdentifierPreparer(resourceGroupName, name, domainOwnershipIdentifierName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDomainOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetDomainOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDomainOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetDomainOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDomainOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetDomainOwnershipIdentifierPreparer prepares the GetDomainOwnershipIdentifier request.
+func (client AppsClient) GetDomainOwnershipIdentifierPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetDomainOwnershipIdentifierSender sends the GetDomainOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetDomainOwnershipIdentifierResponder handles the response to the GetDomainOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetDomainOwnershipIdentifierResponder(resp *http.Response) (result Identifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetDomainOwnershipIdentifierSlot get domain ownership identifier for web
+// app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier. slot is name of the deployment slot. If a slot
+// is not specified, the API will delete the binding for the production slot.
+func (client AppsClient) GetDomainOwnershipIdentifierSlot(resourceGroupName string, name string, domainOwnershipIdentifierName string, slot string) (result Identifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetDomainOwnershipIdentifierSlot")
+ }
+
+ req, err := client.GetDomainOwnershipIdentifierSlotPreparer(resourceGroupName, name, domainOwnershipIdentifierName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDomainOwnershipIdentifierSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetDomainOwnershipIdentifierSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDomainOwnershipIdentifierSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetDomainOwnershipIdentifierSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetDomainOwnershipIdentifierSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetDomainOwnershipIdentifierSlotPreparer prepares the GetDomainOwnershipIdentifierSlot request.
+func (client AppsClient) GetDomainOwnershipIdentifierSlotPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetDomainOwnershipIdentifierSlotSender sends the GetDomainOwnershipIdentifierSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetDomainOwnershipIdentifierSlotResponder handles the response to the GetDomainOwnershipIdentifierSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetDomainOwnershipIdentifierSlotResponder(resp *http.Response) (result Identifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetHostNameBinding get the named hostname binding for an app (or deployment
+// slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. hostName is hostname in the hostname
+// binding.
+func (client AppsClient) GetHostNameBinding(resourceGroupName string, name string, hostName string) (result HostNameBinding, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetHostNameBinding")
+ }
+
+ req, err := client.GetHostNameBindingPreparer(resourceGroupName, name, hostName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHostNameBinding", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetHostNameBindingSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHostNameBinding", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetHostNameBindingResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHostNameBinding", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetHostNameBindingPreparer prepares the GetHostNameBinding request.
+func (client AppsClient) GetHostNameBindingPreparer(resourceGroupName string, name string, hostName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hostName": autorest.Encode("path", hostName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hostNameBindings/{hostName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetHostNameBindingSender sends the GetHostNameBinding request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetHostNameBindingSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetHostNameBindingResponder handles the response to the GetHostNameBinding request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetHostNameBindingResponder(resp *http.Response) (result HostNameBinding, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetHostNameBindingSlot get the named hostname binding for an app (or
+// deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API the named binding for the production slot.
+// hostName is hostname in the hostname binding.
+func (client AppsClient) GetHostNameBindingSlot(resourceGroupName string, name string, slot string, hostName string) (result HostNameBinding, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetHostNameBindingSlot")
+ }
+
+ req, err := client.GetHostNameBindingSlotPreparer(resourceGroupName, name, slot, hostName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHostNameBindingSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetHostNameBindingSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHostNameBindingSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetHostNameBindingSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHostNameBindingSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetHostNameBindingSlotPreparer prepares the GetHostNameBindingSlot request.
+func (client AppsClient) GetHostNameBindingSlotPreparer(resourceGroupName string, name string, slot string, hostName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hostName": autorest.Encode("path", hostName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hostNameBindings/{hostName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetHostNameBindingSlotSender sends the GetHostNameBindingSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetHostNameBindingSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetHostNameBindingSlotResponder handles the response to the GetHostNameBindingSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetHostNameBindingSlotResponder(resp *http.Response) (result HostNameBinding, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetHybridConnection retrieves a specific Service Bus Hybrid Connection used
+// by this Web App.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection
+func (client AppsClient) GetHybridConnection(resourceGroupName string, name string, namespaceName string, relayName string) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetHybridConnection")
+ }
+
+ req, err := client.GetHybridConnectionPreparer(resourceGroupName, name, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHybridConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetHybridConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHybridConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHybridConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetHybridConnectionPreparer prepares the GetHybridConnection request.
+func (client AppsClient) GetHybridConnectionPreparer(resourceGroupName string, name string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetHybridConnectionSender sends the GetHybridConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetHybridConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetHybridConnectionResponder handles the response to the GetHybridConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetHybridConnectionResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetHybridConnectionSlot retrieves a specific Service Bus Hybrid Connection
+// used by this Web App.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection slot is the name of the slot for the web app.
+func (client AppsClient) GetHybridConnectionSlot(resourceGroupName string, name string, namespaceName string, relayName string, slot string) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetHybridConnectionSlot")
+ }
+
+ req, err := client.GetHybridConnectionSlotPreparer(resourceGroupName, name, namespaceName, relayName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHybridConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetHybridConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHybridConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetHybridConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetHybridConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetHybridConnectionSlotPreparer prepares the GetHybridConnectionSlot request.
+func (client AppsClient) GetHybridConnectionSlotPreparer(resourceGroupName string, name string, namespaceName string, relayName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetHybridConnectionSlotSender sends the GetHybridConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetHybridConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetHybridConnectionSlotResponder handles the response to the GetHybridConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetHybridConnectionSlotResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetInstanceDeployment get a deployment by its ID for an app, a specific
+// deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID. instanceID is iD of a
+// specific scaled-out instance. This is the value of the name property in the
+// JSON response from "GET api/sites/{siteName}/instances"
+func (client AppsClient) GetInstanceDeployment(resourceGroupName string, name string, ID string, instanceID string) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetInstanceDeployment")
+ }
+
+ req, err := client.GetInstanceDeploymentPreparer(resourceGroupName, name, ID, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetInstanceDeployment", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetInstanceDeploymentSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetInstanceDeployment", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetInstanceDeploymentResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetInstanceDeployment", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetInstanceDeploymentPreparer prepares the GetInstanceDeployment request.
+func (client AppsClient) GetInstanceDeploymentPreparer(resourceGroupName string, name string, ID string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/instances/{instanceId}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetInstanceDeploymentSender sends the GetInstanceDeployment request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetInstanceDeploymentSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetInstanceDeploymentResponder handles the response to the GetInstanceDeployment request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetInstanceDeploymentResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetInstanceDeploymentSlot get a deployment by its ID for an app, a specific
+// deployment slot, and/or a specific scaled-out instance.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. ID is deployment ID. slot is name of the
+// deployment slot. If a slot is not specified, the API gets a deployment for
+// the production slot. instanceID is iD of a specific scaled-out instance.
+// This is the value of the name property in the JSON response from "GET
+// api/sites/{siteName}/instances"
+func (client AppsClient) GetInstanceDeploymentSlot(resourceGroupName string, name string, ID string, slot string, instanceID string) (result Deployment, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetInstanceDeploymentSlot")
+ }
+
+ req, err := client.GetInstanceDeploymentSlotPreparer(resourceGroupName, name, ID, slot, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetInstanceDeploymentSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetInstanceDeploymentSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetInstanceDeploymentSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetInstanceDeploymentSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetInstanceDeploymentSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetInstanceDeploymentSlotPreparer prepares the GetInstanceDeploymentSlot request.
+func (client AppsClient) GetInstanceDeploymentSlotPreparer(resourceGroupName string, name string, ID string, slot string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "id": autorest.Encode("path", ID),
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/instances/{instanceId}/deployments/{id}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetInstanceDeploymentSlotSender sends the GetInstanceDeploymentSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetInstanceDeploymentSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetInstanceDeploymentSlotResponder handles the response to the GetInstanceDeploymentSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetInstanceDeploymentSlotResponder(resp *http.Response) (result Deployment, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetMigrateMySQLStatus returns the status of MySql in app migration, if one
+// is active, and whether or not MySql in app is enabled
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app
+func (client AppsClient) GetMigrateMySQLStatus(resourceGroupName string, name string) (result MigrateMySQLStatus, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetMigrateMySQLStatus")
+ }
+
+ req, err := client.GetMigrateMySQLStatusPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetMigrateMySQLStatus", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetMigrateMySQLStatusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetMigrateMySQLStatus", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetMigrateMySQLStatusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetMigrateMySQLStatus", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetMigrateMySQLStatusPreparer prepares the GetMigrateMySQLStatus request.
+func (client AppsClient) GetMigrateMySQLStatusPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/migratemysql/status", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetMigrateMySQLStatusSender sends the GetMigrateMySQLStatus request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetMigrateMySQLStatusSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetMigrateMySQLStatusResponder handles the response to the GetMigrateMySQLStatus request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetMigrateMySQLStatusResponder(resp *http.Response) (result MigrateMySQLStatus, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetMigrateMySQLStatusSlot returns the status of MySql in app migration, if
+// one is active, and whether or not MySql in app is enabled
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app slot is name of the deployment slot
+func (client AppsClient) GetMigrateMySQLStatusSlot(resourceGroupName string, name string, slot string) (result MigrateMySQLStatus, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetMigrateMySQLStatusSlot")
+ }
+
+ req, err := client.GetMigrateMySQLStatusSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetMigrateMySQLStatusSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetMigrateMySQLStatusSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetMigrateMySQLStatusSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetMigrateMySQLStatusSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetMigrateMySQLStatusSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetMigrateMySQLStatusSlotPreparer prepares the GetMigrateMySQLStatusSlot request.
+func (client AppsClient) GetMigrateMySQLStatusSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/migratemysql/status", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetMigrateMySQLStatusSlotSender sends the GetMigrateMySQLStatusSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetMigrateMySQLStatusSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetMigrateMySQLStatusSlotResponder handles the response to the GetMigrateMySQLStatusSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetMigrateMySQLStatusSlotResponder(resp *http.Response) (result MigrateMySQLStatus, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetPremierAddOn gets a named add-on of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. premierAddOnName is add-on name.
+func (client AppsClient) GetPremierAddOn(resourceGroupName string, name string, premierAddOnName string) (result PremierAddOn, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetPremierAddOn")
+ }
+
+ req, err := client.GetPremierAddOnPreparer(resourceGroupName, name, premierAddOnName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetPremierAddOn", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetPremierAddOnSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetPremierAddOn", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetPremierAddOnResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetPremierAddOn", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPremierAddOnPreparer prepares the GetPremierAddOn request.
+func (client AppsClient) GetPremierAddOnPreparer(resourceGroupName string, name string, premierAddOnName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "premierAddOnName": autorest.Encode("path", premierAddOnName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/premieraddons/{premierAddOnName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetPremierAddOnSender sends the GetPremierAddOn request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetPremierAddOnSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetPremierAddOnResponder handles the response to the GetPremierAddOn request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetPremierAddOnResponder(resp *http.Response) (result PremierAddOn, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetPremierAddOnSlot gets a named add-on of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. premierAddOnName is add-on name. slot is
+// name of the deployment slot. If a slot is not specified, the API will get
+// the named add-on for the production slot.
+func (client AppsClient) GetPremierAddOnSlot(resourceGroupName string, name string, premierAddOnName string, slot string) (result PremierAddOn, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetPremierAddOnSlot")
+ }
+
+ req, err := client.GetPremierAddOnSlotPreparer(resourceGroupName, name, premierAddOnName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetPremierAddOnSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetPremierAddOnSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetPremierAddOnSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetPremierAddOnSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetPremierAddOnSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPremierAddOnSlotPreparer prepares the GetPremierAddOnSlot request.
+func (client AppsClient) GetPremierAddOnSlotPreparer(resourceGroupName string, name string, premierAddOnName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "premierAddOnName": autorest.Encode("path", premierAddOnName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/premieraddons/{premierAddOnName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetPremierAddOnSlotSender sends the GetPremierAddOnSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetPremierAddOnSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetPremierAddOnSlotResponder handles the response to the GetPremierAddOnSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetPremierAddOnSlotResponder(resp *http.Response) (result PremierAddOn, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetRelayServiceConnection gets a hybrid connection configuration by its
+// name.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection.
+func (client AppsClient) GetRelayServiceConnection(resourceGroupName string, name string, entityName string) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetRelayServiceConnection")
+ }
+
+ req, err := client.GetRelayServiceConnectionPreparer(resourceGroupName, name, entityName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetRelayServiceConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetRelayServiceConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetRelayServiceConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetRelayServiceConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetRelayServiceConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetRelayServiceConnectionPreparer prepares the GetRelayServiceConnection request.
+func (client AppsClient) GetRelayServiceConnectionPreparer(resourceGroupName string, name string, entityName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetRelayServiceConnectionSender sends the GetRelayServiceConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetRelayServiceConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetRelayServiceConnectionResponder handles the response to the GetRelayServiceConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetRelayServiceConnectionResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetRelayServiceConnectionSlot gets a hybrid connection configuration by its
+// name.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection. slot is name of the deployment slot. If a slot is not specified,
+// the API will get a hybrid connection for the production slot.
+func (client AppsClient) GetRelayServiceConnectionSlot(resourceGroupName string, name string, entityName string, slot string) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetRelayServiceConnectionSlot")
+ }
+
+ req, err := client.GetRelayServiceConnectionSlotPreparer(resourceGroupName, name, entityName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetRelayServiceConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetRelayServiceConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetRelayServiceConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetRelayServiceConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetRelayServiceConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetRelayServiceConnectionSlotPreparer prepares the GetRelayServiceConnectionSlot request.
+func (client AppsClient) GetRelayServiceConnectionSlotPreparer(resourceGroupName string, name string, entityName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetRelayServiceConnectionSlotSender sends the GetRelayServiceConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetRelayServiceConnectionSlotResponder handles the response to the GetRelayServiceConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetRelayServiceConnectionSlotResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetResourceHealthMetadata gets the category of ResourceHealthMetadata to use
+// for the given site
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app
+func (client AppsClient) GetResourceHealthMetadata(resourceGroupName string, name string) (result ResourceHealthMetadata, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetResourceHealthMetadata")
+ }
+
+ req, err := client.GetResourceHealthMetadataPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetResourceHealthMetadata", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetResourceHealthMetadataSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetResourceHealthMetadata", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResourceHealthMetadataResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetResourceHealthMetadata", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetResourceHealthMetadataPreparer prepares the GetResourceHealthMetadata request.
+func (client AppsClient) GetResourceHealthMetadataPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/resourceHealthMetadata", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetResourceHealthMetadataSender sends the GetResourceHealthMetadata request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetResourceHealthMetadataSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResourceHealthMetadataResponder handles the response to the GetResourceHealthMetadata request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetResourceHealthMetadataResponder(resp *http.Response) (result ResourceHealthMetadata, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetResourceHealthMetadataSlot gets the category of ResourceHealthMetadata to
+// use for the given site
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app slot is name of web app slot. If not
+// specified then will default to production slot.
+func (client AppsClient) GetResourceHealthMetadataSlot(resourceGroupName string, name string, slot string) (result ResourceHealthMetadata, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetResourceHealthMetadataSlot")
+ }
+
+ req, err := client.GetResourceHealthMetadataSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetResourceHealthMetadataSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetResourceHealthMetadataSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetResourceHealthMetadataSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResourceHealthMetadataSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetResourceHealthMetadataSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetResourceHealthMetadataSlotPreparer prepares the GetResourceHealthMetadataSlot request.
+func (client AppsClient) GetResourceHealthMetadataSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/resourceHealthMetadata", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetResourceHealthMetadataSlotSender sends the GetResourceHealthMetadataSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetResourceHealthMetadataSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResourceHealthMetadataSlotResponder handles the response to the GetResourceHealthMetadataSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetResourceHealthMetadataSlotResponder(resp *http.Response) (result ResourceHealthMetadata, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetSitePhpErrorLogFlag gets web app's event logs.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app
+func (client AppsClient) GetSitePhpErrorLogFlag(resourceGroupName string, name string) (result SitePhpErrorLogFlag, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetSitePhpErrorLogFlag")
+ }
+
+ req, err := client.GetSitePhpErrorLogFlagPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSitePhpErrorLogFlag", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSitePhpErrorLogFlagSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSitePhpErrorLogFlag", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetSitePhpErrorLogFlagResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSitePhpErrorLogFlag", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetSitePhpErrorLogFlagPreparer prepares the GetSitePhpErrorLogFlag request.
+func (client AppsClient) GetSitePhpErrorLogFlagPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/phplogging", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSitePhpErrorLogFlagSender sends the GetSitePhpErrorLogFlag request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetSitePhpErrorLogFlagSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetSitePhpErrorLogFlagResponder handles the response to the GetSitePhpErrorLogFlag request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetSitePhpErrorLogFlagResponder(resp *http.Response) (result SitePhpErrorLogFlag, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetSitePhpErrorLogFlagSlot gets web app's event logs.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app slot is name of web app slot. If not
+// specified then will default to production slot.
+func (client AppsClient) GetSitePhpErrorLogFlagSlot(resourceGroupName string, name string, slot string) (result SitePhpErrorLogFlag, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetSitePhpErrorLogFlagSlot")
+ }
+
+ req, err := client.GetSitePhpErrorLogFlagSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSitePhpErrorLogFlagSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSitePhpErrorLogFlagSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSitePhpErrorLogFlagSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetSitePhpErrorLogFlagSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSitePhpErrorLogFlagSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetSitePhpErrorLogFlagSlotPreparer prepares the GetSitePhpErrorLogFlagSlot request.
+func (client AppsClient) GetSitePhpErrorLogFlagSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/phplogging", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSitePhpErrorLogFlagSlotSender sends the GetSitePhpErrorLogFlagSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetSitePhpErrorLogFlagSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetSitePhpErrorLogFlagSlotResponder handles the response to the GetSitePhpErrorLogFlagSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetSitePhpErrorLogFlagSlotResponder(resp *http.Response) (result SitePhpErrorLogFlag, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetSlot gets the details of a web, mobile, or API app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. By
+// default, this API returns the production slot.
+func (client AppsClient) GetSlot(resourceGroupName string, name string, slot string) (result Site, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetSlot")
+ }
+
+ req, err := client.GetSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetSlotPreparer prepares the GetSlot request.
+func (client AppsClient) GetSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSlotSender sends the GetSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetSlotResponder handles the response to the GetSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetSlotResponder(resp *http.Response) (result Site, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetSourceControl gets the source control configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) GetSourceControl(resourceGroupName string, name string) (result SiteSourceControl, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetSourceControl")
+ }
+
+ req, err := client.GetSourceControlPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSourceControl", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSourceControlSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSourceControl", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetSourceControlResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSourceControl", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetSourceControlPreparer prepares the GetSourceControl request.
+func (client AppsClient) GetSourceControlPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/sourcecontrols/web", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSourceControlSender sends the GetSourceControl request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetSourceControlSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetSourceControlResponder handles the response to the GetSourceControl request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetSourceControlResponder(resp *http.Response) (result SiteSourceControl, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetSourceControlSlot gets the source control configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the source control configuration for
+// the production slot.
+func (client AppsClient) GetSourceControlSlot(resourceGroupName string, name string, slot string) (result SiteSourceControl, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetSourceControlSlot")
+ }
+
+ req, err := client.GetSourceControlSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSourceControlSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSourceControlSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSourceControlSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetSourceControlSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetSourceControlSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetSourceControlSlotPreparer prepares the GetSourceControlSlot request.
+func (client AppsClient) GetSourceControlSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/sourcecontrols/web", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSourceControlSlotSender sends the GetSourceControlSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetSourceControlSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetSourceControlSlotResponder handles the response to the GetSourceControlSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetSourceControlSlotResponder(resp *http.Response) (result SiteSourceControl, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVnetConnection gets a virtual network the app (or deployment slot) is
+// connected to by name.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the virtual network.
+func (client AppsClient) GetVnetConnection(resourceGroupName string, name string, vnetName string) (result VnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetVnetConnection")
+ }
+
+ req, err := client.GetVnetConnectionPreparer(resourceGroupName, name, vnetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVnetConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVnetConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetVnetConnectionPreparer prepares the GetVnetConnection request.
+func (client AppsClient) GetVnetConnectionPreparer(resourceGroupName string, name string, vnetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetVnetConnectionSender sends the GetVnetConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetVnetConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetVnetConnectionResponder handles the response to the GetVnetConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetVnetConnectionResponder(resp *http.Response) (result VnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVnetConnectionGateway gets an app's Virtual Network gateway.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the Virtual Network.
+// gatewayName is name of the gateway. Currently, the only supported string is
+// "primary".
+func (client AppsClient) GetVnetConnectionGateway(resourceGroupName string, name string, vnetName string, gatewayName string) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetVnetConnectionGateway")
+ }
+
+ req, err := client.GetVnetConnectionGatewayPreparer(resourceGroupName, name, vnetName, gatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionGateway", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVnetConnectionGatewaySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionGateway", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVnetConnectionGatewayResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionGateway", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetVnetConnectionGatewayPreparer prepares the GetVnetConnectionGateway request.
+func (client AppsClient) GetVnetConnectionGatewayPreparer(resourceGroupName string, name string, vnetName string, gatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetVnetConnectionGatewaySender sends the GetVnetConnectionGateway request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetVnetConnectionGatewaySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetVnetConnectionGatewayResponder handles the response to the GetVnetConnectionGateway request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetVnetConnectionGatewayResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVnetConnectionGatewaySlot gets an app's Virtual Network gateway.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the Virtual Network.
+// gatewayName is name of the gateway. Currently, the only supported string is
+// "primary". slot is name of the deployment slot. If a slot is not specified,
+// the API will get a gateway for the production slot's Virtual Network.
+func (client AppsClient) GetVnetConnectionGatewaySlot(resourceGroupName string, name string, vnetName string, gatewayName string, slot string) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetVnetConnectionGatewaySlot")
+ }
+
+ req, err := client.GetVnetConnectionGatewaySlotPreparer(resourceGroupName, name, vnetName, gatewayName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionGatewaySlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVnetConnectionGatewaySlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionGatewaySlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVnetConnectionGatewaySlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionGatewaySlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetVnetConnectionGatewaySlotPreparer prepares the GetVnetConnectionGatewaySlot request.
+func (client AppsClient) GetVnetConnectionGatewaySlotPreparer(resourceGroupName string, name string, vnetName string, gatewayName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetVnetConnectionGatewaySlotSender sends the GetVnetConnectionGatewaySlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetVnetConnectionGatewaySlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetVnetConnectionGatewaySlotResponder handles the response to the GetVnetConnectionGatewaySlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetVnetConnectionGatewaySlotResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVnetConnectionSlot gets a virtual network the app (or deployment slot) is
+// connected to by name.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the virtual network.
+// slot is name of the deployment slot. If a slot is not specified, the API
+// will get the named virtual network for the production slot.
+func (client AppsClient) GetVnetConnectionSlot(resourceGroupName string, name string, vnetName string, slot string) (result VnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "GetVnetConnectionSlot")
+ }
+
+ req, err := client.GetVnetConnectionSlotPreparer(resourceGroupName, name, vnetName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVnetConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVnetConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "GetVnetConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetVnetConnectionSlotPreparer prepares the GetVnetConnectionSlot request.
+func (client AppsClient) GetVnetConnectionSlotPreparer(resourceGroupName string, name string, vnetName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetVnetConnectionSlotSender sends the GetVnetConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) GetVnetConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetVnetConnectionSlotResponder handles the response to the GetVnetConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) GetVnetConnectionSlotResponder(resp *http.Response) (result VnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// IsCloneable shows whether an app can be cloned to another resource group or
+// subscription.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) IsCloneable(resourceGroupName string, name string) (result SiteCloneability, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "IsCloneable")
+ }
+
+ req, err := client.IsCloneablePreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "IsCloneable", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.IsCloneableSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "IsCloneable", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.IsCloneableResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "IsCloneable", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// IsCloneablePreparer prepares the IsCloneable request.
+func (client AppsClient) IsCloneablePreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/iscloneable", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// IsCloneableSender sends the IsCloneable request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) IsCloneableSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// IsCloneableResponder handles the response to the IsCloneable request. The method always
+// closes the http.Response Body.
+func (client AppsClient) IsCloneableResponder(resp *http.Response) (result SiteCloneability, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// IsCloneableSlot shows whether an app can be cloned to another resource group
+// or subscription.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. By
+// default, this API returns information on the production slot.
+func (client AppsClient) IsCloneableSlot(resourceGroupName string, name string, slot string) (result SiteCloneability, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "IsCloneableSlot")
+ }
+
+ req, err := client.IsCloneableSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "IsCloneableSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.IsCloneableSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "IsCloneableSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.IsCloneableSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "IsCloneableSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// IsCloneableSlotPreparer prepares the IsCloneableSlot request.
+func (client AppsClient) IsCloneableSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/iscloneable", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// IsCloneableSlotSender sends the IsCloneableSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) IsCloneableSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// IsCloneableSlotResponder handles the response to the IsCloneableSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) IsCloneableSlotResponder(resp *http.Response) (result SiteCloneability, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List get all apps for a subscription.
+func (client AppsClient) List() (result AppCollection, err error) {
+ req, err := client.ListPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client AppsClient) ListPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/sites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListResponder(resp *http.Response) (result AppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 AppsClient) ListNextResults(lastResults AppCollection) (result AppCollection, err error) {
+ req, err := lastResults.AppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "List", 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, "web.AppsClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListApplicationSettings gets the application settings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListApplicationSettings(resourceGroupName string, name string) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListApplicationSettings")
+ }
+
+ req, err := client.ListApplicationSettingsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListApplicationSettings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListApplicationSettingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListApplicationSettings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListApplicationSettingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListApplicationSettings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListApplicationSettingsPreparer prepares the ListApplicationSettings request.
+func (client AppsClient) ListApplicationSettingsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/appsettings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListApplicationSettingsSender sends the ListApplicationSettings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListApplicationSettingsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListApplicationSettingsResponder handles the response to the ListApplicationSettings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListApplicationSettingsResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListApplicationSettingsSlot gets the application settings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the application settings for the
+// production slot.
+func (client AppsClient) ListApplicationSettingsSlot(resourceGroupName string, name string, slot string) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListApplicationSettingsSlot")
+ }
+
+ req, err := client.ListApplicationSettingsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListApplicationSettingsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListApplicationSettingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListApplicationSettingsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListApplicationSettingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListApplicationSettingsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListApplicationSettingsSlotPreparer prepares the ListApplicationSettingsSlot request.
+func (client AppsClient) ListApplicationSettingsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/appsettings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListApplicationSettingsSlotSender sends the ListApplicationSettingsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListApplicationSettingsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListApplicationSettingsSlotResponder handles the response to the ListApplicationSettingsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListApplicationSettingsSlotResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListBackups gets existing backups of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListBackups(resourceGroupName string, name string) (result BackupItemCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListBackups")
+ }
+
+ req, err := client.ListBackupsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackups", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListBackupsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackups", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListBackupsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackups", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListBackupsPreparer prepares the ListBackups request.
+func (client AppsClient) ListBackupsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/backups", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListBackupsSender sends the ListBackups request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListBackupsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListBackupsResponder handles the response to the ListBackups request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListBackupsResponder(resp *http.Response) (result BackupItemCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListBackupsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListBackupsNextResults(lastResults BackupItemCollection) (result BackupItemCollection, err error) {
+ req, err := lastResults.BackupItemCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListBackups", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListBackupsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListBackups", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListBackupsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackups", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListBackupsSlot gets existing backups of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get backups of the production slot.
+func (client AppsClient) ListBackupsSlot(resourceGroupName string, name string, slot string) (result BackupItemCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListBackupsSlot")
+ }
+
+ req, err := client.ListBackupsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListBackupsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListBackupsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListBackupsSlotPreparer prepares the ListBackupsSlot request.
+func (client AppsClient) ListBackupsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/backups", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListBackupsSlotSender sends the ListBackupsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListBackupsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListBackupsSlotResponder handles the response to the ListBackupsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListBackupsSlotResponder(resp *http.Response) (result BackupItemCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListBackupsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListBackupsSlotNextResults(lastResults BackupItemCollection) (result BackupItemCollection, err error) {
+ req, err := lastResults.BackupItemCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListBackupsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListBackupsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListBackupStatusSecrets gets status of a web app backup that may be in
+// progress, including secrets associated with the backup, such as the Azure
+// Storage SAS URL. Also can be used to update the SAS URL for the backup if a
+// new URL is passed in the request body.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app backupID is id of backup request is
+// information on backup request
+func (client AppsClient) ListBackupStatusSecrets(resourceGroupName string, name string, backupID string, request BackupRequest) (result BackupItem, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: request,
+ Constraints: []validation.Constraint{{Target: "request.BackupRequestProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule.FrequencyInterval", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.KeepAtLeastOneBackup", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.RetentionPeriodInDays", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListBackupStatusSecrets")
+ }
+
+ req, err := client.ListBackupStatusSecretsPreparer(resourceGroupName, name, backupID, request)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupStatusSecrets", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListBackupStatusSecretsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupStatusSecrets", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListBackupStatusSecretsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupStatusSecrets", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListBackupStatusSecretsPreparer prepares the ListBackupStatusSecrets request.
+func (client AppsClient) ListBackupStatusSecretsPreparer(resourceGroupName string, name string, backupID string, request BackupRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/backups/{backupId}/list", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListBackupStatusSecretsSender sends the ListBackupStatusSecrets request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListBackupStatusSecretsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListBackupStatusSecretsResponder handles the response to the ListBackupStatusSecrets request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListBackupStatusSecretsResponder(resp *http.Response) (result BackupItem, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListBackupStatusSecretsSlot gets status of a web app backup that may be in
+// progress, including secrets associated with the backup, such as the Azure
+// Storage SAS URL. Also can be used to update the SAS URL for the backup if a
+// new URL is passed in the request body.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app backupID is id of backup request is
+// information on backup request slot is name of web app slot. If not specified
+// then will default to production slot.
+func (client AppsClient) ListBackupStatusSecretsSlot(resourceGroupName string, name string, backupID string, request BackupRequest, slot string) (result BackupItem, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: request,
+ Constraints: []validation.Constraint{{Target: "request.BackupRequestProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule.FrequencyInterval", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.KeepAtLeastOneBackup", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.RetentionPeriodInDays", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListBackupStatusSecretsSlot")
+ }
+
+ req, err := client.ListBackupStatusSecretsSlotPreparer(resourceGroupName, name, backupID, request, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupStatusSecretsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListBackupStatusSecretsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupStatusSecretsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListBackupStatusSecretsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListBackupStatusSecretsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListBackupStatusSecretsSlotPreparer prepares the ListBackupStatusSecretsSlot request.
+func (client AppsClient) ListBackupStatusSecretsSlotPreparer(resourceGroupName string, name string, backupID string, request BackupRequest, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/backups/{backupId}/list", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListBackupStatusSecretsSlotSender sends the ListBackupStatusSecretsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListBackupStatusSecretsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListBackupStatusSecretsSlotResponder handles the response to the ListBackupStatusSecretsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListBackupStatusSecretsSlotResponder(resp *http.Response) (result BackupItem, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroup gets all web, mobile, and API apps in the specified
+// resource group.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. includeSlots is specify true to include deployment
+// slots in results. The default is false, which only gives you the production
+// slot of all apps.
+func (client AppsClient) ListByResourceGroup(resourceGroupName string, includeSlots *bool) (result AppCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListByResourceGroup")
+ }
+
+ req, err := client.ListByResourceGroupPreparer(resourceGroupName, includeSlots)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client AppsClient) ListByResourceGroupPreparer(resourceGroupName string, includeSlots *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if includeSlots != nil {
+ queryParameters["includeSlots"] = autorest.Encode("query", *includeSlots)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListByResourceGroupResponder(resp *http.Response) (result AppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListByResourceGroupNextResults(lastResults AppCollection) (result AppCollection, err error) {
+ req, err := lastResults.AppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListByResourceGroup", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListConfigurations list the configurations of an app
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListConfigurations(resourceGroupName string, name string) (result SiteConfigResourceCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListConfigurations")
+ }
+
+ req, err := client.ListConfigurationsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurations", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListConfigurationsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurations", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListConfigurationsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurations", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListConfigurationsPreparer prepares the ListConfigurations request.
+func (client AppsClient) ListConfigurationsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListConfigurationsSender sends the ListConfigurations request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListConfigurationsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListConfigurationsResponder handles the response to the ListConfigurations request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListConfigurationsResponder(resp *http.Response) (result SiteConfigResourceCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListConfigurationsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListConfigurationsNextResults(lastResults SiteConfigResourceCollection) (result SiteConfigResourceCollection, err error) {
+ req, err := lastResults.SiteConfigResourceCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurations", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListConfigurationsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurations", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListConfigurationsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurations", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListConfigurationSnapshotInfo gets a list of web app configuration snapshots
+// identifiers. Each element of the list contains a timestamp and the ID of the
+// snapshot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListConfigurationSnapshotInfo(resourceGroupName string, name string) (result ListSiteConfigurationSnapshotInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListConfigurationSnapshotInfo")
+ }
+
+ req, err := client.ListConfigurationSnapshotInfoPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationSnapshotInfo", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListConfigurationSnapshotInfoSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationSnapshotInfo", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListConfigurationSnapshotInfoResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationSnapshotInfo", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListConfigurationSnapshotInfoPreparer prepares the ListConfigurationSnapshotInfo request.
+func (client AppsClient) ListConfigurationSnapshotInfoPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/web/snapshots", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListConfigurationSnapshotInfoSender sends the ListConfigurationSnapshotInfo request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListConfigurationSnapshotInfoSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListConfigurationSnapshotInfoResponder handles the response to the ListConfigurationSnapshotInfo request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListConfigurationSnapshotInfoResponder(resp *http.Response) (result ListSiteConfigurationSnapshotInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListConfigurationSnapshotInfoSlot gets a list of web app configuration
+// snapshots identifiers. Each element of the list contains a timestamp and the
+// ID of the snapshot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will return configuration for the production
+// slot.
+func (client AppsClient) ListConfigurationSnapshotInfoSlot(resourceGroupName string, name string, slot string) (result ListSiteConfigurationSnapshotInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListConfigurationSnapshotInfoSlot")
+ }
+
+ req, err := client.ListConfigurationSnapshotInfoSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationSnapshotInfoSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListConfigurationSnapshotInfoSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationSnapshotInfoSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListConfigurationSnapshotInfoSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationSnapshotInfoSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListConfigurationSnapshotInfoSlotPreparer prepares the ListConfigurationSnapshotInfoSlot request.
+func (client AppsClient) ListConfigurationSnapshotInfoSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/web/snapshots", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListConfigurationSnapshotInfoSlotSender sends the ListConfigurationSnapshotInfoSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListConfigurationSnapshotInfoSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListConfigurationSnapshotInfoSlotResponder handles the response to the ListConfigurationSnapshotInfoSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListConfigurationSnapshotInfoSlotResponder(resp *http.Response) (result ListSiteConfigurationSnapshotInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListConfigurationsSlot list the configurations of an app
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will return configuration for the production
+// slot.
+func (client AppsClient) ListConfigurationsSlot(resourceGroupName string, name string, slot string) (result SiteConfigResourceCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListConfigurationsSlot")
+ }
+
+ req, err := client.ListConfigurationsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListConfigurationsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListConfigurationsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListConfigurationsSlotPreparer prepares the ListConfigurationsSlot request.
+func (client AppsClient) ListConfigurationsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListConfigurationsSlotSender sends the ListConfigurationsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListConfigurationsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListConfigurationsSlotResponder handles the response to the ListConfigurationsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListConfigurationsSlotResponder(resp *http.Response) (result SiteConfigResourceCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListConfigurationsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListConfigurationsSlotNextResults(lastResults SiteConfigResourceCollection) (result SiteConfigResourceCollection, err error) {
+ req, err := lastResults.SiteConfigResourceCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListConfigurationsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListConfigurationsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConfigurationsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListConnectionStrings gets the connection strings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListConnectionStrings(resourceGroupName string, name string) (result ConnectionStringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListConnectionStrings")
+ }
+
+ req, err := client.ListConnectionStringsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConnectionStrings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListConnectionStringsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConnectionStrings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListConnectionStringsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConnectionStrings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListConnectionStringsPreparer prepares the ListConnectionStrings request.
+func (client AppsClient) ListConnectionStringsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/connectionstrings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListConnectionStringsSender sends the ListConnectionStrings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListConnectionStringsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListConnectionStringsResponder handles the response to the ListConnectionStrings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListConnectionStringsResponder(resp *http.Response) (result ConnectionStringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListConnectionStringsSlot gets the connection strings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the connection settings for the
+// production slot.
+func (client AppsClient) ListConnectionStringsSlot(resourceGroupName string, name string, slot string) (result ConnectionStringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListConnectionStringsSlot")
+ }
+
+ req, err := client.ListConnectionStringsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConnectionStringsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListConnectionStringsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConnectionStringsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListConnectionStringsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListConnectionStringsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListConnectionStringsSlotPreparer prepares the ListConnectionStringsSlot request.
+func (client AppsClient) ListConnectionStringsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/connectionstrings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListConnectionStringsSlotSender sends the ListConnectionStringsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListConnectionStringsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListConnectionStringsSlotResponder handles the response to the ListConnectionStringsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListConnectionStringsSlotResponder(resp *http.Response) (result ConnectionStringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListDeployments list deployments for an app, or a deployment slot, or for an
+// instance of a scaled-out app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListDeployments(resourceGroupName string, name string) (result DeploymentCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListDeployments")
+ }
+
+ req, err := client.ListDeploymentsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeployments", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListDeploymentsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeployments", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListDeploymentsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeployments", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListDeploymentsPreparer prepares the ListDeployments request.
+func (client AppsClient) ListDeploymentsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/deployments", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListDeploymentsSender sends the ListDeployments request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListDeploymentsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListDeploymentsResponder handles the response to the ListDeployments request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListDeploymentsResponder(resp *http.Response) (result DeploymentCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListDeploymentsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListDeploymentsNextResults(lastResults DeploymentCollection) (result DeploymentCollection, err error) {
+ req, err := lastResults.DeploymentCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDeployments", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListDeploymentsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDeployments", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListDeploymentsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeployments", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListDeploymentsSlot list deployments for an app, or a deployment slot, or
+// for an instance of a scaled-out app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API returns deployments for the production slot.
+func (client AppsClient) ListDeploymentsSlot(resourceGroupName string, name string, slot string) (result DeploymentCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListDeploymentsSlot")
+ }
+
+ req, err := client.ListDeploymentsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeploymentsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListDeploymentsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeploymentsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListDeploymentsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeploymentsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListDeploymentsSlotPreparer prepares the ListDeploymentsSlot request.
+func (client AppsClient) ListDeploymentsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/deployments", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListDeploymentsSlotSender sends the ListDeploymentsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListDeploymentsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListDeploymentsSlotResponder handles the response to the ListDeploymentsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListDeploymentsSlotResponder(resp *http.Response) (result DeploymentCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListDeploymentsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListDeploymentsSlotNextResults(lastResults DeploymentCollection) (result DeploymentCollection, err error) {
+ req, err := lastResults.DeploymentCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDeploymentsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListDeploymentsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDeploymentsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListDeploymentsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDeploymentsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListDomainOwnershipIdentifiers lists ownership identifiers for domain
+// associated with web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListDomainOwnershipIdentifiers(resourceGroupName string, name string) (result IdentifierCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListDomainOwnershipIdentifiers")
+ }
+
+ req, err := client.ListDomainOwnershipIdentifiersPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiers", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListDomainOwnershipIdentifiersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiers", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListDomainOwnershipIdentifiersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiers", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListDomainOwnershipIdentifiersPreparer prepares the ListDomainOwnershipIdentifiers request.
+func (client AppsClient) ListDomainOwnershipIdentifiersPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/domainOwnershipIdentifiers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListDomainOwnershipIdentifiersSender sends the ListDomainOwnershipIdentifiers request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListDomainOwnershipIdentifiersSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListDomainOwnershipIdentifiersResponder handles the response to the ListDomainOwnershipIdentifiers request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListDomainOwnershipIdentifiersResponder(resp *http.Response) (result IdentifierCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListDomainOwnershipIdentifiersNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListDomainOwnershipIdentifiersNextResults(lastResults IdentifierCollection) (result IdentifierCollection, err error) {
+ req, err := lastResults.IdentifierCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiers", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListDomainOwnershipIdentifiersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiers", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListDomainOwnershipIdentifiersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiers", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListDomainOwnershipIdentifiersSlot lists ownership identifiers for domain
+// associated with web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will delete the binding for the production
+// slot.
+func (client AppsClient) ListDomainOwnershipIdentifiersSlot(resourceGroupName string, name string, slot string) (result IdentifierCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListDomainOwnershipIdentifiersSlot")
+ }
+
+ req, err := client.ListDomainOwnershipIdentifiersSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiersSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListDomainOwnershipIdentifiersSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiersSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListDomainOwnershipIdentifiersSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiersSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListDomainOwnershipIdentifiersSlotPreparer prepares the ListDomainOwnershipIdentifiersSlot request.
+func (client AppsClient) ListDomainOwnershipIdentifiersSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/domainOwnershipIdentifiers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListDomainOwnershipIdentifiersSlotSender sends the ListDomainOwnershipIdentifiersSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListDomainOwnershipIdentifiersSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListDomainOwnershipIdentifiersSlotResponder handles the response to the ListDomainOwnershipIdentifiersSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListDomainOwnershipIdentifiersSlotResponder(resp *http.Response) (result IdentifierCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListDomainOwnershipIdentifiersSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListDomainOwnershipIdentifiersSlotNextResults(lastResults IdentifierCollection) (result IdentifierCollection, err error) {
+ req, err := lastResults.IdentifierCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiersSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListDomainOwnershipIdentifiersSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiersSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListDomainOwnershipIdentifiersSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListDomainOwnershipIdentifiersSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListHostNameBindings get hostname bindings for an app or a deployment slot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListHostNameBindings(resourceGroupName string, name string) (result HostNameBindingCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListHostNameBindings")
+ }
+
+ req, err := client.ListHostNameBindingsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHostNameBindingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHostNameBindingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHostNameBindingsPreparer prepares the ListHostNameBindings request.
+func (client AppsClient) ListHostNameBindingsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hostNameBindings", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHostNameBindingsSender sends the ListHostNameBindings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListHostNameBindingsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHostNameBindingsResponder handles the response to the ListHostNameBindings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListHostNameBindingsResponder(resp *http.Response) (result HostNameBindingCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHostNameBindingsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListHostNameBindingsNextResults(lastResults HostNameBindingCollection) (result HostNameBindingCollection, err error) {
+ req, err := lastResults.HostNameBindingCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindings", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListHostNameBindingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindings", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListHostNameBindingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindings", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListHostNameBindingsSlot get hostname bindings for an app or a deployment
+// slot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API gets hostname bindings for the production
+// slot.
+func (client AppsClient) ListHostNameBindingsSlot(resourceGroupName string, name string, slot string) (result HostNameBindingCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListHostNameBindingsSlot")
+ }
+
+ req, err := client.ListHostNameBindingsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindingsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHostNameBindingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindingsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHostNameBindingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindingsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHostNameBindingsSlotPreparer prepares the ListHostNameBindingsSlot request.
+func (client AppsClient) ListHostNameBindingsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hostNameBindings", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHostNameBindingsSlotSender sends the ListHostNameBindingsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListHostNameBindingsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHostNameBindingsSlotResponder handles the response to the ListHostNameBindingsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListHostNameBindingsSlotResponder(resp *http.Response) (result HostNameBindingCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHostNameBindingsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListHostNameBindingsSlotNextResults(lastResults HostNameBindingCollection) (result HostNameBindingCollection, err error) {
+ req, err := lastResults.HostNameBindingCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindingsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListHostNameBindingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindingsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListHostNameBindingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHostNameBindingsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListHybridConnectionKeys gets the send key name and value for a Hybrid
+// Connection.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection
+func (client AppsClient) ListHybridConnectionKeys(resourceGroupName string, name string, namespaceName string, relayName string) (result HybridConnectionKey, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListHybridConnectionKeys")
+ }
+
+ req, err := client.ListHybridConnectionKeysPreparer(resourceGroupName, name, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHybridConnectionKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHybridConnectionKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHybridConnectionKeysPreparer prepares the ListHybridConnectionKeys request.
+func (client AppsClient) ListHybridConnectionKeysPreparer(resourceGroupName string, name string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}/listKeys", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHybridConnectionKeysSender sends the ListHybridConnectionKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListHybridConnectionKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHybridConnectionKeysResponder handles the response to the ListHybridConnectionKeys request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListHybridConnectionKeysResponder(resp *http.Response) (result HybridConnectionKey, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHybridConnectionKeysSlot gets the send key name and value for a Hybrid
+// Connection.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection slot is the name of the slot for the web app.
+func (client AppsClient) ListHybridConnectionKeysSlot(resourceGroupName string, name string, namespaceName string, relayName string, slot string) (result HybridConnectionKey, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListHybridConnectionKeysSlot")
+ }
+
+ req, err := client.ListHybridConnectionKeysSlotPreparer(resourceGroupName, name, namespaceName, relayName, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionKeysSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHybridConnectionKeysSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionKeysSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHybridConnectionKeysSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionKeysSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHybridConnectionKeysSlotPreparer prepares the ListHybridConnectionKeysSlot request.
+func (client AppsClient) ListHybridConnectionKeysSlotPreparer(resourceGroupName string, name string, namespaceName string, relayName string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}/listKeys", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHybridConnectionKeysSlotSender sends the ListHybridConnectionKeysSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListHybridConnectionKeysSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHybridConnectionKeysSlotResponder handles the response to the ListHybridConnectionKeysSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListHybridConnectionKeysSlotResponder(resp *http.Response) (result HybridConnectionKey, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHybridConnections retrieves all Service Bus Hybrid Connections used by
+// this Web App.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app
+func (client AppsClient) ListHybridConnections(resourceGroupName string, name string) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListHybridConnections")
+ }
+
+ req, err := client.ListHybridConnectionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnections", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHybridConnectionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnections", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHybridConnectionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnections", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHybridConnectionsPreparer prepares the ListHybridConnections request.
+func (client AppsClient) ListHybridConnectionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridConnectionRelays", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHybridConnectionsSender sends the ListHybridConnections request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListHybridConnectionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHybridConnectionsResponder handles the response to the ListHybridConnections request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListHybridConnectionsResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHybridConnectionsSlot retrieves all Service Bus Hybrid Connections used
+// by this Web App.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app slot is the name of the slot for
+// the web app.
+func (client AppsClient) ListHybridConnectionsSlot(resourceGroupName string, name string, slot string) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListHybridConnectionsSlot")
+ }
+
+ req, err := client.ListHybridConnectionsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHybridConnectionsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHybridConnectionsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListHybridConnectionsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHybridConnectionsSlotPreparer prepares the ListHybridConnectionsSlot request.
+func (client AppsClient) ListHybridConnectionsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridConnectionRelays", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHybridConnectionsSlotSender sends the ListHybridConnectionsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListHybridConnectionsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHybridConnectionsSlotResponder handles the response to the ListHybridConnectionsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListHybridConnectionsSlotResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListInstanceDeployments list deployments for an app, or a deployment slot,
+// or for an instance of a scaled-out app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. instanceID is the ID of a specific
+// scaled-out instance. This is the value of the name property in the JSON
+// response from "GET api/sites/{siteName}/instances"
+func (client AppsClient) ListInstanceDeployments(resourceGroupName string, name string, instanceID string) (result DeploymentCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListInstanceDeployments")
+ }
+
+ req, err := client.ListInstanceDeploymentsPreparer(resourceGroupName, name, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeployments", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListInstanceDeploymentsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeployments", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListInstanceDeploymentsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeployments", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListInstanceDeploymentsPreparer prepares the ListInstanceDeployments request.
+func (client AppsClient) ListInstanceDeploymentsPreparer(resourceGroupName string, name string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/instances/{instanceId}/deployments", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListInstanceDeploymentsSender sends the ListInstanceDeployments request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListInstanceDeploymentsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListInstanceDeploymentsResponder handles the response to the ListInstanceDeployments request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListInstanceDeploymentsResponder(resp *http.Response) (result DeploymentCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListInstanceDeploymentsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListInstanceDeploymentsNextResults(lastResults DeploymentCollection) (result DeploymentCollection, err error) {
+ req, err := lastResults.DeploymentCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeployments", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListInstanceDeploymentsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeployments", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListInstanceDeploymentsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeployments", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListInstanceDeploymentsSlot list deployments for an app, or a deployment
+// slot, or for an instance of a scaled-out app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API returns deployments for the production slot.
+// instanceID is the ID of a specific scaled-out instance. This is the value of
+// the name property in the JSON response from "GET
+// api/sites/{siteName}/instances"
+func (client AppsClient) ListInstanceDeploymentsSlot(resourceGroupName string, name string, slot string, instanceID string) (result DeploymentCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListInstanceDeploymentsSlot")
+ }
+
+ req, err := client.ListInstanceDeploymentsSlotPreparer(resourceGroupName, name, slot, instanceID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeploymentsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListInstanceDeploymentsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeploymentsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListInstanceDeploymentsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeploymentsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListInstanceDeploymentsSlotPreparer prepares the ListInstanceDeploymentsSlot request.
+func (client AppsClient) ListInstanceDeploymentsSlotPreparer(resourceGroupName string, name string, slot string, instanceID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instanceId": autorest.Encode("path", instanceID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/instances/{instanceId}/deployments", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListInstanceDeploymentsSlotSender sends the ListInstanceDeploymentsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListInstanceDeploymentsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListInstanceDeploymentsSlotResponder handles the response to the ListInstanceDeploymentsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListInstanceDeploymentsSlotResponder(resp *http.Response) (result DeploymentCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListInstanceDeploymentsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListInstanceDeploymentsSlotNextResults(lastResults DeploymentCollection) (result DeploymentCollection, err error) {
+ req, err := lastResults.DeploymentCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeploymentsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListInstanceDeploymentsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeploymentsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListInstanceDeploymentsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceDeploymentsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListInstanceIdentifiers gets all scale-out instances of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListInstanceIdentifiers(resourceGroupName string, name string) (result AppInstanceCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListInstanceIdentifiers")
+ }
+
+ req, err := client.ListInstanceIdentifiersPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiers", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListInstanceIdentifiersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiers", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListInstanceIdentifiersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiers", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListInstanceIdentifiersPreparer prepares the ListInstanceIdentifiers request.
+func (client AppsClient) ListInstanceIdentifiersPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/instances", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListInstanceIdentifiersSender sends the ListInstanceIdentifiers request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListInstanceIdentifiersSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListInstanceIdentifiersResponder handles the response to the ListInstanceIdentifiers request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListInstanceIdentifiersResponder(resp *http.Response) (result AppInstanceCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListInstanceIdentifiersNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListInstanceIdentifiersNextResults(lastResults AppInstanceCollection) (result AppInstanceCollection, err error) {
+ req, err := lastResults.AppInstanceCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiers", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListInstanceIdentifiersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiers", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListInstanceIdentifiersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiers", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListInstanceIdentifiersSlot gets all scale-out instances of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API gets the production slot instances.
+func (client AppsClient) ListInstanceIdentifiersSlot(resourceGroupName string, name string, slot string) (result AppInstanceCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListInstanceIdentifiersSlot")
+ }
+
+ req, err := client.ListInstanceIdentifiersSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiersSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListInstanceIdentifiersSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiersSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListInstanceIdentifiersSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiersSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListInstanceIdentifiersSlotPreparer prepares the ListInstanceIdentifiersSlot request.
+func (client AppsClient) ListInstanceIdentifiersSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/instances", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListInstanceIdentifiersSlotSender sends the ListInstanceIdentifiersSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListInstanceIdentifiersSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListInstanceIdentifiersSlotResponder handles the response to the ListInstanceIdentifiersSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListInstanceIdentifiersSlotResponder(resp *http.Response) (result AppInstanceCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListInstanceIdentifiersSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListInstanceIdentifiersSlotNextResults(lastResults AppInstanceCollection) (result AppInstanceCollection, err error) {
+ req, err := lastResults.AppInstanceCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiersSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListInstanceIdentifiersSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiersSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListInstanceIdentifiersSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListInstanceIdentifiersSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMetadata gets the metadata of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListMetadata(resourceGroupName string, name string) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListMetadata")
+ }
+
+ req, err := client.ListMetadataPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetadata", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetadataSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetadata", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetadataResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetadata", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetadataPreparer prepares the ListMetadata request.
+func (client AppsClient) ListMetadataPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/metadata/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetadataSender sends the ListMetadata request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListMetadataSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetadataResponder handles the response to the ListMetadata request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListMetadataResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetadataSlot gets the metadata of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the metadata for the production
+// slot.
+func (client AppsClient) ListMetadataSlot(resourceGroupName string, name string, slot string) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListMetadataSlot")
+ }
+
+ req, err := client.ListMetadataSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetadataSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetadataSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetadataSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetadataSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetadataSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetadataSlotPreparer prepares the ListMetadataSlot request.
+func (client AppsClient) ListMetadataSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/metadata/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetadataSlotSender sends the ListMetadataSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListMetadataSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetadataSlotResponder handles the response to the ListMetadataSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListMetadataSlotResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricDefinitions gets all metric definitions of an app (or deployment
+// slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListMetricDefinitions(resourceGroupName string, name string) (result ResourceMetricDefinitionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListMetricDefinitions")
+ }
+
+ req, err := client.ListMetricDefinitionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricDefinitionsPreparer prepares the ListMetricDefinitions request.
+func (client AppsClient) ListMetricDefinitionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListMetricDefinitionsResponder(resp *http.Response) (result ResourceMetricDefinitionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricDefinitionsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListMetricDefinitionsNextResults(lastResults ResourceMetricDefinitionCollection) (result ResourceMetricDefinitionCollection, err error) {
+ req, err := lastResults.ResourceMetricDefinitionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitions", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitions", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitions", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMetricDefinitionsSlot gets all metric definitions of an app (or
+// deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get metric definitions of the production
+// slot.
+func (client AppsClient) ListMetricDefinitionsSlot(resourceGroupName string, name string, slot string) (result ResourceMetricDefinitionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListMetricDefinitionsSlot")
+ }
+
+ req, err := client.ListMetricDefinitionsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitionsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricDefinitionsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitionsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricDefinitionsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitionsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricDefinitionsSlotPreparer prepares the ListMetricDefinitionsSlot request.
+func (client AppsClient) ListMetricDefinitionsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricDefinitionsSlotSender sends the ListMetricDefinitionsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListMetricDefinitionsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricDefinitionsSlotResponder handles the response to the ListMetricDefinitionsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListMetricDefinitionsSlotResponder(resp *http.Response) (result ResourceMetricDefinitionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricDefinitionsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListMetricDefinitionsSlotNextResults(lastResults ResourceMetricDefinitionCollection) (result ResourceMetricDefinitionCollection, err error) {
+ req, err := lastResults.ResourceMetricDefinitionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitionsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMetricDefinitionsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitionsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMetricDefinitionsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricDefinitionsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMetrics gets performance metrics of an app (or deployment slot, if
+// specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. details is specify "true" to include
+// metric details in the response. It is "false" by default. filter is return
+// only metrics specified in the filter (using OData syntax). For example:
+// $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime
+// eq '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and
+// timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppsClient) ListMetrics(resourceGroupName string, name string, details *bool, filter string) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListMetrics")
+ }
+
+ req, err := client.ListMetricsPreparer(resourceGroupName, name, details, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetrics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetrics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetrics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricsPreparer prepares the ListMetrics request.
+func (client AppsClient) ListMetricsPreparer(resourceGroupName string, name string, details *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricsSender sends the ListMetrics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListMetricsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricsResponder handles the response to the ListMetrics request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListMetricsResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListMetricsNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetrics", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetrics", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetrics", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMetricsSlot gets performance metrics of an app (or deployment slot, if
+// specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get metrics of the production slot.
+// details is specify "true" to include metric details in the response. It is
+// "false" by default. filter is return only metrics specified in the filter
+// (using OData syntax). For example: $filter=(name.value eq 'Metric1' or
+// name.value eq 'Metric2') and startTime eq '2014-01-01T00:00:00Z' and endTime
+// eq '2014-12-31T23:59:59Z' and timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppsClient) ListMetricsSlot(resourceGroupName string, name string, slot string, details *bool, filter string) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListMetricsSlot")
+ }
+
+ req, err := client.ListMetricsSlotPreparer(resourceGroupName, name, slot, details, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricsSlotPreparer prepares the ListMetricsSlot request.
+func (client AppsClient) ListMetricsSlotPreparer(resourceGroupName string, name string, slot string, details *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricsSlotSender sends the ListMetricsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListMetricsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricsSlotResponder handles the response to the ListMetricsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListMetricsSlotResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListMetricsSlotNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMetricsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMetricsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListMetricsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListNetworkFeatures gets all network features used by the app (or deployment
+// slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. view is the type of view. This can either
+// be "summary" or "detailed".
+func (client AppsClient) ListNetworkFeatures(resourceGroupName string, name string, view string) (result NetworkFeatures, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListNetworkFeatures")
+ }
+
+ req, err := client.ListNetworkFeaturesPreparer(resourceGroupName, name, view)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListNetworkFeatures", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListNetworkFeaturesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListNetworkFeatures", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListNetworkFeaturesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListNetworkFeatures", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListNetworkFeaturesPreparer prepares the ListNetworkFeatures request.
+func (client AppsClient) ListNetworkFeaturesPreparer(resourceGroupName string, name string, view string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "view": autorest.Encode("path", view),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/networkFeatures/{view}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListNetworkFeaturesSender sends the ListNetworkFeatures request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListNetworkFeaturesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListNetworkFeaturesResponder handles the response to the ListNetworkFeatures request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListNetworkFeaturesResponder(resp *http.Response) (result NetworkFeatures, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListNetworkFeaturesSlot gets all network features used by the app (or
+// deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. view is the type of view. This can either
+// be "summary" or "detailed". slot is name of the deployment slot. If a slot
+// is not specified, the API will get network features for the production slot.
+func (client AppsClient) ListNetworkFeaturesSlot(resourceGroupName string, name string, view string, slot string) (result NetworkFeatures, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListNetworkFeaturesSlot")
+ }
+
+ req, err := client.ListNetworkFeaturesSlotPreparer(resourceGroupName, name, view, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListNetworkFeaturesSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListNetworkFeaturesSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListNetworkFeaturesSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListNetworkFeaturesSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListNetworkFeaturesSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListNetworkFeaturesSlotPreparer prepares the ListNetworkFeaturesSlot request.
+func (client AppsClient) ListNetworkFeaturesSlotPreparer(resourceGroupName string, name string, view string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "view": autorest.Encode("path", view),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/networkFeatures/{view}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListNetworkFeaturesSlotSender sends the ListNetworkFeaturesSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListNetworkFeaturesSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListNetworkFeaturesSlotResponder handles the response to the ListNetworkFeaturesSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListNetworkFeaturesSlotResponder(resp *http.Response) (result NetworkFeatures, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPerfMonCounters gets perfmon counters for web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app filter is return only usages/metrics
+// specified in the filter. Filter conforms to odata syntax. Example:
+// $filter=(startTime eq '2014-01-01T00:00:00Z' and endTime eq
+// '2014-12-31T23:59:59Z' and timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppsClient) ListPerfMonCounters(resourceGroupName string, name string, filter string) (result PerfMonCounterCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPerfMonCounters")
+ }
+
+ req, err := client.ListPerfMonCountersPreparer(resourceGroupName, name, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCounters", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPerfMonCountersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCounters", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPerfMonCountersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCounters", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPerfMonCountersPreparer prepares the ListPerfMonCounters request.
+func (client AppsClient) ListPerfMonCountersPreparer(resourceGroupName string, name string, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/perfcounters", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListPerfMonCountersSender sends the ListPerfMonCounters request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPerfMonCountersSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListPerfMonCountersResponder handles the response to the ListPerfMonCounters request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPerfMonCountersResponder(resp *http.Response) (result PerfMonCounterCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPerfMonCountersNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListPerfMonCountersNextResults(lastResults PerfMonCounterCollection) (result PerfMonCounterCollection, err error) {
+ req, err := lastResults.PerfMonCounterCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCounters", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListPerfMonCountersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCounters", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListPerfMonCountersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCounters", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListPerfMonCountersSlot gets perfmon counters for web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app slot is name of web app slot. If not
+// specified then will default to production slot. **** CURRENTLY UNUSED *****
+// filter is return only usages/metrics specified in the filter. Filter
+// conforms to odata syntax. Example: $filter=(startTime eq
+// '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain
+// eq duration'[Hour|Minute|Day]'.
+func (client AppsClient) ListPerfMonCountersSlot(resourceGroupName string, name string, slot string, filter string) (result PerfMonCounterCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPerfMonCountersSlot")
+ }
+
+ req, err := client.ListPerfMonCountersSlotPreparer(resourceGroupName, name, slot, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCountersSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPerfMonCountersSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCountersSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPerfMonCountersSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCountersSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPerfMonCountersSlotPreparer prepares the ListPerfMonCountersSlot request.
+func (client AppsClient) ListPerfMonCountersSlotPreparer(resourceGroupName string, name string, slot string, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/perfcounters", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListPerfMonCountersSlotSender sends the ListPerfMonCountersSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPerfMonCountersSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListPerfMonCountersSlotResponder handles the response to the ListPerfMonCountersSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPerfMonCountersSlotResponder(resp *http.Response) (result PerfMonCounterCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPerfMonCountersSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListPerfMonCountersSlotNextResults(lastResults PerfMonCounterCollection) (result PerfMonCounterCollection, err error) {
+ req, err := lastResults.PerfMonCounterCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCountersSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListPerfMonCountersSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCountersSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListPerfMonCountersSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPerfMonCountersSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListPremierAddOns gets the premier add-ons of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListPremierAddOns(resourceGroupName string, name string) (result PremierAddOn, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPremierAddOns")
+ }
+
+ req, err := client.ListPremierAddOnsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPremierAddOns", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPremierAddOnsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPremierAddOns", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPremierAddOnsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPremierAddOns", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPremierAddOnsPreparer prepares the ListPremierAddOns request.
+func (client AppsClient) ListPremierAddOnsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/premieraddons", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListPremierAddOnsSender sends the ListPremierAddOns request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPremierAddOnsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListPremierAddOnsResponder handles the response to the ListPremierAddOns request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPremierAddOnsResponder(resp *http.Response) (result PremierAddOn, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPremierAddOnsSlot gets the premier add-ons of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the premier add-ons for the
+// production slot.
+func (client AppsClient) ListPremierAddOnsSlot(resourceGroupName string, name string, slot string) (result PremierAddOn, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPremierAddOnsSlot")
+ }
+
+ req, err := client.ListPremierAddOnsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPremierAddOnsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPremierAddOnsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPremierAddOnsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPremierAddOnsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPremierAddOnsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPremierAddOnsSlotPreparer prepares the ListPremierAddOnsSlot request.
+func (client AppsClient) ListPremierAddOnsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/premieraddons", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListPremierAddOnsSlotSender sends the ListPremierAddOnsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPremierAddOnsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListPremierAddOnsSlotResponder handles the response to the ListPremierAddOnsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPremierAddOnsSlotResponder(resp *http.Response) (result PremierAddOn, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPublishingCredentials gets the Git/FTP publishing credentials of an app.
+// This method may poll for completion. Polling can be canceled by passing the
+// cancel channel argument. The channel will be used to cancel polling and any
+// outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListPublishingCredentials(resourceGroupName string, name string, cancel <-chan struct{}) (<-chan User, <-chan error) {
+ resultChan := make(chan User, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPublishingCredentials")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result User
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.ListPublishingCredentialsPreparer(resourceGroupName, name, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingCredentials", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPublishingCredentialsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingCredentials", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPublishingCredentialsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingCredentials", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// ListPublishingCredentialsPreparer prepares the ListPublishingCredentials request.
+func (client AppsClient) ListPublishingCredentialsPreparer(resourceGroupName string, name string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/publishingcredentials/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// ListPublishingCredentialsSender sends the ListPublishingCredentials request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPublishingCredentialsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// ListPublishingCredentialsResponder handles the response to the ListPublishingCredentials request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPublishingCredentialsResponder(resp *http.Response) (result User, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPublishingCredentialsSlot gets the Git/FTP publishing credentials of an
+// app. This method may poll for completion. Polling can be canceled by passing
+// the cancel channel argument. The channel will be used to cancel polling and
+// any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get the publishing credentials for the
+// production slot.
+func (client AppsClient) ListPublishingCredentialsSlot(resourceGroupName string, name string, slot string, cancel <-chan struct{}) (<-chan User, <-chan error) {
+ resultChan := make(chan User, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPublishingCredentialsSlot")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result User
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.ListPublishingCredentialsSlotPreparer(resourceGroupName, name, slot, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingCredentialsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPublishingCredentialsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingCredentialsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPublishingCredentialsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingCredentialsSlot", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// ListPublishingCredentialsSlotPreparer prepares the ListPublishingCredentialsSlot request.
+func (client AppsClient) ListPublishingCredentialsSlotPreparer(resourceGroupName string, name string, slot string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/publishingcredentials/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// ListPublishingCredentialsSlotSender sends the ListPublishingCredentialsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPublishingCredentialsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// ListPublishingCredentialsSlotResponder handles the response to the ListPublishingCredentialsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPublishingCredentialsSlotResponder(resp *http.Response) (result User, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPublishingProfileXMLWithSecrets gets the publishing profile for an app
+// (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. publishingProfileOptions is specifies
+// publishingProfileOptions for publishing profile. For example, use {"format":
+// "FileZilla3"} to get a FileZilla publishing profile.
+func (client AppsClient) ListPublishingProfileXMLWithSecrets(resourceGroupName string, name string, publishingProfileOptions CsmPublishingProfileOptions) (result ReadCloser, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecrets")
+ }
+
+ req, err := client.ListPublishingProfileXMLWithSecretsPreparer(resourceGroupName, name, publishingProfileOptions)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecrets", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPublishingProfileXMLWithSecretsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecrets", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPublishingProfileXMLWithSecretsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecrets", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPublishingProfileXMLWithSecretsPreparer prepares the ListPublishingProfileXMLWithSecrets request.
+func (client AppsClient) ListPublishingProfileXMLWithSecretsPreparer(resourceGroupName string, name string, publishingProfileOptions CsmPublishingProfileOptions) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/publishxml", pathParameters),
+ autorest.WithJSON(publishingProfileOptions),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListPublishingProfileXMLWithSecretsSender sends the ListPublishingProfileXMLWithSecrets request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPublishingProfileXMLWithSecretsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListPublishingProfileXMLWithSecretsResponder handles the response to the ListPublishingProfileXMLWithSecrets request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPublishingProfileXMLWithSecretsResponder(resp *http.Response) (result ReadCloser, err error) {
+ result.Value = &resp.Body
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK))
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPublishingProfileXMLWithSecretsSlot gets the publishing profile for an
+// app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. publishingProfileOptions is specifies
+// publishingProfileOptions for publishing profile. For example, use {"format":
+// "FileZilla3"} to get a FileZilla publishing profile. slot is name of the
+// deployment slot. If a slot is not specified, the API will get the publishing
+// profile for the production slot.
+func (client AppsClient) ListPublishingProfileXMLWithSecretsSlot(resourceGroupName string, name string, publishingProfileOptions CsmPublishingProfileOptions, slot string) (result ReadCloser, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecretsSlot")
+ }
+
+ req, err := client.ListPublishingProfileXMLWithSecretsSlotPreparer(resourceGroupName, name, publishingProfileOptions, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecretsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPublishingProfileXMLWithSecretsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecretsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPublishingProfileXMLWithSecretsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListPublishingProfileXMLWithSecretsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPublishingProfileXMLWithSecretsSlotPreparer prepares the ListPublishingProfileXMLWithSecretsSlot request.
+func (client AppsClient) ListPublishingProfileXMLWithSecretsSlotPreparer(resourceGroupName string, name string, publishingProfileOptions CsmPublishingProfileOptions, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/publishxml", pathParameters),
+ autorest.WithJSON(publishingProfileOptions),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListPublishingProfileXMLWithSecretsSlotSender sends the ListPublishingProfileXMLWithSecretsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListPublishingProfileXMLWithSecretsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListPublishingProfileXMLWithSecretsSlotResponder handles the response to the ListPublishingProfileXMLWithSecretsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListPublishingProfileXMLWithSecretsSlotResponder(resp *http.Response) (result ReadCloser, err error) {
+ result.Value = &resp.Body
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK))
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListRelayServiceConnections gets hybrid connections configured for an app
+// (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListRelayServiceConnections(resourceGroupName string, name string) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListRelayServiceConnections")
+ }
+
+ req, err := client.ListRelayServiceConnectionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListRelayServiceConnections", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListRelayServiceConnectionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListRelayServiceConnections", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListRelayServiceConnectionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListRelayServiceConnections", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListRelayServiceConnectionsPreparer prepares the ListRelayServiceConnections request.
+func (client AppsClient) ListRelayServiceConnectionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridconnection", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListRelayServiceConnectionsSender sends the ListRelayServiceConnections request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListRelayServiceConnectionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListRelayServiceConnectionsResponder handles the response to the ListRelayServiceConnections request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListRelayServiceConnectionsResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListRelayServiceConnectionsSlot gets hybrid connections configured for an
+// app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get hybrid connections for the
+// production slot.
+func (client AppsClient) ListRelayServiceConnectionsSlot(resourceGroupName string, name string, slot string) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListRelayServiceConnectionsSlot")
+ }
+
+ req, err := client.ListRelayServiceConnectionsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListRelayServiceConnectionsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListRelayServiceConnectionsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListRelayServiceConnectionsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListRelayServiceConnectionsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListRelayServiceConnectionsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListRelayServiceConnectionsSlotPreparer prepares the ListRelayServiceConnectionsSlot request.
+func (client AppsClient) ListRelayServiceConnectionsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridconnection", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListRelayServiceConnectionsSlotSender sends the ListRelayServiceConnectionsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListRelayServiceConnectionsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListRelayServiceConnectionsSlotResponder handles the response to the ListRelayServiceConnectionsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListRelayServiceConnectionsSlotResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSitePushSettings gets the Push settings associated with web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app
+func (client AppsClient) ListSitePushSettings(resourceGroupName string, name string) (result PushSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSitePushSettings")
+ }
+
+ req, err := client.ListSitePushSettingsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSitePushSettings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSitePushSettingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSitePushSettings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSitePushSettingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSitePushSettings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSitePushSettingsPreparer prepares the ListSitePushSettings request.
+func (client AppsClient) ListSitePushSettingsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/pushsettings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSitePushSettingsSender sends the ListSitePushSettings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSitePushSettingsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSitePushSettingsResponder handles the response to the ListSitePushSettings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSitePushSettingsResponder(resp *http.Response) (result PushSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSitePushSettingsSlot gets the Push settings associated with web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app slot is name of web app slot. If not
+// specified then will default to production slot.
+func (client AppsClient) ListSitePushSettingsSlot(resourceGroupName string, name string, slot string) (result PushSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSitePushSettingsSlot")
+ }
+
+ req, err := client.ListSitePushSettingsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSitePushSettingsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSitePushSettingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSitePushSettingsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSitePushSettingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSitePushSettingsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSitePushSettingsSlotPreparer prepares the ListSitePushSettingsSlot request.
+func (client AppsClient) ListSitePushSettingsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/pushsettings/list", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSitePushSettingsSlotSender sends the ListSitePushSettingsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSitePushSettingsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSitePushSettingsSlotResponder handles the response to the ListSitePushSettingsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSitePushSettingsSlotResponder(resp *http.Response) (result PushSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSlotConfigurationNames gets the names of app settings and connection
+// strings that stick to the slot (not swapped).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListSlotConfigurationNames(resourceGroupName string, name string) (result SlotConfigNamesResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSlotConfigurationNames")
+ }
+
+ req, err := client.ListSlotConfigurationNamesPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotConfigurationNames", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSlotConfigurationNamesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotConfigurationNames", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSlotConfigurationNamesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotConfigurationNames", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSlotConfigurationNamesPreparer prepares the ListSlotConfigurationNames request.
+func (client AppsClient) ListSlotConfigurationNamesPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/slotConfigNames", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSlotConfigurationNamesSender sends the ListSlotConfigurationNames request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSlotConfigurationNamesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSlotConfigurationNamesResponder handles the response to the ListSlotConfigurationNames request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSlotConfigurationNamesResponder(resp *http.Response) (result SlotConfigNamesResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSlotDifferencesFromProduction get the difference in configuration
+// settings between two web app slots.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slotSwapEntity is jSON object that
+// contains the target slot name. See example.
+func (client AppsClient) ListSlotDifferencesFromProduction(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity) (result SlotDifferenceCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: slotSwapEntity,
+ Constraints: []validation.Constraint{{Target: "slotSwapEntity.TargetSlot", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "slotSwapEntity.PreserveVnet", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSlotDifferencesFromProduction")
+ }
+
+ req, err := client.ListSlotDifferencesFromProductionPreparer(resourceGroupName, name, slotSwapEntity)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesFromProduction", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSlotDifferencesFromProductionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesFromProduction", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSlotDifferencesFromProductionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesFromProduction", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSlotDifferencesFromProductionPreparer prepares the ListSlotDifferencesFromProduction request.
+func (client AppsClient) ListSlotDifferencesFromProductionPreparer(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slotsdiffs", pathParameters),
+ autorest.WithJSON(slotSwapEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSlotDifferencesFromProductionSender sends the ListSlotDifferencesFromProduction request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSlotDifferencesFromProductionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSlotDifferencesFromProductionResponder handles the response to the ListSlotDifferencesFromProduction request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSlotDifferencesFromProductionResponder(resp *http.Response) (result SlotDifferenceCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSlotDifferencesFromProductionNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListSlotDifferencesFromProductionNextResults(lastResults SlotDifferenceCollection) (result SlotDifferenceCollection, err error) {
+ req, err := lastResults.SlotDifferenceCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesFromProduction", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListSlotDifferencesFromProductionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesFromProduction", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListSlotDifferencesFromProductionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesFromProduction", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListSlotDifferencesSlot get the difference in configuration settings between
+// two web app slots.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slotSwapEntity is jSON object that
+// contains the target slot name. See example. slot is name of the source slot.
+// If a slot is not specified, the production slot is used as the source slot.
+func (client AppsClient) ListSlotDifferencesSlot(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, slot string) (result SlotDifferenceCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: slotSwapEntity,
+ Constraints: []validation.Constraint{{Target: "slotSwapEntity.TargetSlot", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "slotSwapEntity.PreserveVnet", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSlotDifferencesSlot")
+ }
+
+ req, err := client.ListSlotDifferencesSlotPreparer(resourceGroupName, name, slotSwapEntity, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSlotDifferencesSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSlotDifferencesSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSlotDifferencesSlotPreparer prepares the ListSlotDifferencesSlot request.
+func (client AppsClient) ListSlotDifferencesSlotPreparer(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/slotsdiffs", pathParameters),
+ autorest.WithJSON(slotSwapEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSlotDifferencesSlotSender sends the ListSlotDifferencesSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSlotDifferencesSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSlotDifferencesSlotResponder handles the response to the ListSlotDifferencesSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSlotDifferencesSlotResponder(resp *http.Response) (result SlotDifferenceCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSlotDifferencesSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListSlotDifferencesSlotNextResults(lastResults SlotDifferenceCollection) (result SlotDifferenceCollection, err error) {
+ req, err := lastResults.SlotDifferenceCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListSlotDifferencesSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListSlotDifferencesSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlotDifferencesSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListSlots gets an app's deployment slots.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListSlots(resourceGroupName string, name string) (result AppCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSlots")
+ }
+
+ req, err := client.ListSlotsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlots", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSlotsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlots", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSlotsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlots", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSlotsPreparer prepares the ListSlots request.
+func (client AppsClient) ListSlotsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSlotsSender sends the ListSlots request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSlotsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSlotsResponder handles the response to the ListSlots request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSlotsResponder(resp *http.Response) (result AppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSlotsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListSlotsNextResults(lastResults AppCollection) (result AppCollection, err error) {
+ req, err := lastResults.AppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSlots", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListSlotsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSlots", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListSlotsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSlots", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListSnapshots returns all Snapshots to the user.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is website Name
+func (client AppsClient) ListSnapshots(resourceGroupName string, name string) (result SnapshotCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSnapshots")
+ }
+
+ req, err := client.ListSnapshotsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshots", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSnapshotsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshots", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSnapshotsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshots", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSnapshotsPreparer prepares the ListSnapshots request.
+func (client AppsClient) ListSnapshotsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/snapshots", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSnapshotsSender sends the ListSnapshots request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSnapshotsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSnapshotsResponder handles the response to the ListSnapshots request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSnapshotsResponder(resp *http.Response) (result SnapshotCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSnapshotsNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListSnapshotsNextResults(lastResults SnapshotCollection) (result SnapshotCollection, err error) {
+ req, err := lastResults.SnapshotCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshots", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListSnapshotsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshots", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListSnapshotsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshots", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListSnapshotsSlot returns all Snapshots to the user.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is website Name slot is website Slot
+func (client AppsClient) ListSnapshotsSlot(resourceGroupName string, name string, slot string) (result SnapshotCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListSnapshotsSlot")
+ }
+
+ req, err := client.ListSnapshotsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshotsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSnapshotsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshotsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSnapshotsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshotsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSnapshotsSlotPreparer prepares the ListSnapshotsSlot request.
+func (client AppsClient) ListSnapshotsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/snapshots", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSnapshotsSlotSender sends the ListSnapshotsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListSnapshotsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSnapshotsSlotResponder handles the response to the ListSnapshotsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListSnapshotsSlotResponder(resp *http.Response) (result SnapshotCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSnapshotsSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListSnapshotsSlotNextResults(lastResults SnapshotCollection) (result SnapshotCollection, err error) {
+ req, err := lastResults.SnapshotCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshotsSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListSnapshotsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshotsSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListSnapshotsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListSnapshotsSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListUsages gets the quota usage information of an app (or deployment slot,
+// if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. filter is return only information
+// specified in the filter (using OData syntax). For example:
+// $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime
+// eq '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and
+// timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppsClient) ListUsages(resourceGroupName string, name string, filter string) (result CsmUsageQuotaCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListUsages")
+ }
+
+ req, err := client.ListUsagesPreparer(resourceGroupName, name, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsages", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsages", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsages", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListUsagesPreparer prepares the ListUsages request.
+func (client AppsClient) ListUsagesPreparer(resourceGroupName string, name string, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListUsagesSender sends the ListUsages request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListUsagesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListUsagesResponder handles the response to the ListUsages request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListUsagesResponder(resp *http.Response) (result CsmUsageQuotaCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListUsagesNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListUsagesNextResults(lastResults CsmUsageQuotaCollection) (result CsmUsageQuotaCollection, err error) {
+ req, err := lastResults.CsmUsageQuotaCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListUsages", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListUsages", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsages", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListUsagesSlot gets the quota usage information of an app (or deployment
+// slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get quota information of the production
+// slot. filter is return only information specified in the filter (using OData
+// syntax). For example: $filter=(name.value eq 'Metric1' or name.value eq
+// 'Metric2') and startTime eq '2014-01-01T00:00:00Z' and endTime eq
+// '2014-12-31T23:59:59Z' and timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppsClient) ListUsagesSlot(resourceGroupName string, name string, slot string, filter string) (result CsmUsageQuotaCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListUsagesSlot")
+ }
+
+ req, err := client.ListUsagesSlotPreparer(resourceGroupName, name, slot, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsagesSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListUsagesSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsagesSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListUsagesSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsagesSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListUsagesSlotPreparer prepares the ListUsagesSlot request.
+func (client AppsClient) ListUsagesSlotPreparer(resourceGroupName string, name string, slot string, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListUsagesSlotSender sends the ListUsagesSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListUsagesSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListUsagesSlotResponder handles the response to the ListUsagesSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListUsagesSlotResponder(resp *http.Response) (result CsmUsageQuotaCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListUsagesSlotNextResults retrieves the next set of results, if any.
+func (client AppsClient) ListUsagesSlotNextResults(lastResults CsmUsageQuotaCollection) (result CsmUsageQuotaCollection, err error) {
+ req, err := lastResults.CsmUsageQuotaCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListUsagesSlot", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListUsagesSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppsClient", "ListUsagesSlot", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListUsagesSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListUsagesSlot", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListVnetConnections gets the virtual networks the app (or deployment slot)
+// is connected to.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ListVnetConnections(resourceGroupName string, name string) (result ListVnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListVnetConnections")
+ }
+
+ req, err := client.ListVnetConnectionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListVnetConnections", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVnetConnectionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListVnetConnections", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListVnetConnectionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListVnetConnections", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListVnetConnectionsPreparer prepares the ListVnetConnections request.
+func (client AppsClient) ListVnetConnectionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListVnetConnectionsSender sends the ListVnetConnections request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListVnetConnectionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListVnetConnectionsResponder handles the response to the ListVnetConnections request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListVnetConnectionsResponder(resp *http.Response) (result ListVnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListVnetConnectionsSlot gets the virtual networks the app (or deployment
+// slot) is connected to.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will get virtual network connections for the
+// production slot.
+func (client AppsClient) ListVnetConnectionsSlot(resourceGroupName string, name string, slot string) (result ListVnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ListVnetConnectionsSlot")
+ }
+
+ req, err := client.ListVnetConnectionsSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListVnetConnectionsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVnetConnectionsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListVnetConnectionsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListVnetConnectionsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ListVnetConnectionsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListVnetConnectionsSlotPreparer prepares the ListVnetConnectionsSlot request.
+func (client AppsClient) ListVnetConnectionsSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListVnetConnectionsSlotSender sends the ListVnetConnectionsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ListVnetConnectionsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListVnetConnectionsSlotResponder handles the response to the ListVnetConnectionsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ListVnetConnectionsSlotResponder(resp *http.Response) (result ListVnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// MigrateMySQL migrates a local (in-app) MySql database to a remote MySql
+// database. This method may poll for completion. Polling can be canceled by
+// passing the cancel channel argument. The channel will be used to cancel
+// polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app migrationRequestEnvelope is mySql migration
+// options
+func (client AppsClient) MigrateMySQL(resourceGroupName string, name string, migrationRequestEnvelope MigrateMySQLRequest, cancel <-chan struct{}) (<-chan Operation, <-chan error) {
+ resultChan := make(chan Operation, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "MigrateMySQL")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result Operation
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.MigrateMySQLPreparer(resourceGroupName, name, migrationRequestEnvelope, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "MigrateMySQL", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.MigrateMySQLSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "MigrateMySQL", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.MigrateMySQLResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "MigrateMySQL", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// MigrateMySQLPreparer prepares the MigrateMySQL request.
+func (client AppsClient) MigrateMySQLPreparer(resourceGroupName string, name string, migrationRequestEnvelope MigrateMySQLRequest, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/migratemysql", pathParameters),
+ autorest.WithJSON(migrationRequestEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// MigrateMySQLSender sends the MigrateMySQL request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) MigrateMySQLSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// MigrateMySQLResponder handles the response to the MigrateMySQL request. The method always
+// closes the http.Response Body.
+func (client AppsClient) MigrateMySQLResponder(resp *http.Response) (result Operation, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// MigrateStorage restores a web app. This method may poll for completion.
+// Polling can be canceled by passing the cancel channel argument. The channel
+// will be used to cancel polling and any outstanding HTTP requests.
+//
+// subscriptionName is azure subscription resourceGroupName is name of the
+// resource group to which the resource belongs. name is name of web app
+// migrationOptions is migration migrationOptions
+func (client AppsClient) MigrateStorage(subscriptionName string, resourceGroupName string, name string, migrationOptions StorageMigrationOptions, cancel <-chan struct{}) (<-chan StorageMigrationResponse, <-chan error) {
+ resultChan := make(chan StorageMigrationResponse, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "MigrateStorage")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result StorageMigrationResponse
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.MigrateStoragePreparer(subscriptionName, resourceGroupName, name, migrationOptions, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "MigrateStorage", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.MigrateStorageSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "MigrateStorage", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.MigrateStorageResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "MigrateStorage", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// MigrateStoragePreparer prepares the MigrateStorage request.
+func (client AppsClient) MigrateStoragePreparer(subscriptionName string, resourceGroupName string, name string, migrationOptions StorageMigrationOptions, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ "subscriptionName": autorest.Encode("query", subscriptionName),
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/migrate", pathParameters),
+ autorest.WithJSON(migrationOptions),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// MigrateStorageSender sends the MigrateStorage request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) MigrateStorageSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// MigrateStorageResponder handles the response to the MigrateStorage request. The method always
+// closes the http.Response Body.
+func (client AppsClient) MigrateStorageResponder(resp *http.Response) (result StorageMigrationResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Recover recovers a deleted web app. This method may poll for completion.
+// Polling can be canceled by passing the cancel channel argument. The channel
+// will be used to cancel polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app recoveryEntity is snapshot data used for
+// web app recovery. Snapshot information can be obtained by calling
+// GetDeletedSites or GetSiteSnapshots API.
+func (client AppsClient) Recover(resourceGroupName string, name string, recoveryEntity CsmSiteRecoveryEntity, cancel <-chan struct{}) (<-chan RecoverResponse, <-chan error) {
+ resultChan := make(chan RecoverResponse, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "Recover")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result RecoverResponse
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.RecoverPreparer(resourceGroupName, name, recoveryEntity, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Recover", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RecoverSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Recover", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RecoverResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Recover", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// RecoverPreparer prepares the Recover request.
+func (client AppsClient) RecoverPreparer(resourceGroupName string, name string, recoveryEntity CsmSiteRecoveryEntity, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/recover", pathParameters),
+ autorest.WithJSON(recoveryEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// RecoverSender sends the Recover request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RecoverSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// RecoverResponder handles the response to the Recover request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RecoverResponder(resp *http.Response) (result RecoverResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RecoverSiteConfigurationSnapshot reverts the configuration of an app to a
+// previous snapshot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. snapshotID is the ID of the snapshot to
+// read.
+func (client AppsClient) RecoverSiteConfigurationSnapshot(resourceGroupName string, name string, snapshotID string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshot")
+ }
+
+ req, err := client.RecoverSiteConfigurationSnapshotPreparer(resourceGroupName, name, snapshotID)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RecoverSiteConfigurationSnapshotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RecoverSiteConfigurationSnapshotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RecoverSiteConfigurationSnapshotPreparer prepares the RecoverSiteConfigurationSnapshot request.
+func (client AppsClient) RecoverSiteConfigurationSnapshotPreparer(resourceGroupName string, name string, snapshotID string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "snapshotId": autorest.Encode("path", snapshotID),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/web/snapshots/{snapshotId}/recover", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RecoverSiteConfigurationSnapshotSender sends the RecoverSiteConfigurationSnapshot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RecoverSiteConfigurationSnapshotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RecoverSiteConfigurationSnapshotResponder handles the response to the RecoverSiteConfigurationSnapshot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RecoverSiteConfigurationSnapshotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// RecoverSiteConfigurationSnapshotSlot reverts the configuration of an app to
+// a previous snapshot.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. snapshotID is the ID of the snapshot to
+// read. slot is name of the deployment slot. If a slot is not specified, the
+// API will return configuration for the production slot.
+func (client AppsClient) RecoverSiteConfigurationSnapshotSlot(resourceGroupName string, name string, snapshotID string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshotSlot")
+ }
+
+ req, err := client.RecoverSiteConfigurationSnapshotSlotPreparer(resourceGroupName, name, snapshotID, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshotSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RecoverSiteConfigurationSnapshotSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshotSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RecoverSiteConfigurationSnapshotSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSiteConfigurationSnapshotSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RecoverSiteConfigurationSnapshotSlotPreparer prepares the RecoverSiteConfigurationSnapshotSlot request.
+func (client AppsClient) RecoverSiteConfigurationSnapshotSlotPreparer(resourceGroupName string, name string, snapshotID string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "snapshotId": autorest.Encode("path", snapshotID),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/web/snapshots/{snapshotId}/recover", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RecoverSiteConfigurationSnapshotSlotSender sends the RecoverSiteConfigurationSnapshotSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RecoverSiteConfigurationSnapshotSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RecoverSiteConfigurationSnapshotSlotResponder handles the response to the RecoverSiteConfigurationSnapshotSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RecoverSiteConfigurationSnapshotSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// RecoverSlot recovers a deleted web app. This method may poll for completion.
+// Polling can be canceled by passing the cancel channel argument. The channel
+// will be used to cancel polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app recoveryEntity is snapshot data used for
+// web app recovery. Snapshot information can be obtained by calling
+// GetDeletedSites or GetSiteSnapshots API. slot is name of web app slot. If
+// not specified then will default to production slot.
+func (client AppsClient) RecoverSlot(resourceGroupName string, name string, recoveryEntity CsmSiteRecoveryEntity, slot string, cancel <-chan struct{}) (<-chan RecoverResponse, <-chan error) {
+ resultChan := make(chan RecoverResponse, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "RecoverSlot")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result RecoverResponse
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.RecoverSlotPreparer(resourceGroupName, name, recoveryEntity, slot, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RecoverSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RecoverSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RecoverSlot", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// RecoverSlotPreparer prepares the RecoverSlot request.
+func (client AppsClient) RecoverSlotPreparer(resourceGroupName string, name string, recoveryEntity CsmSiteRecoveryEntity, slot string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/recover", pathParameters),
+ autorest.WithJSON(recoveryEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// RecoverSlotSender sends the RecoverSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RecoverSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// RecoverSlotResponder handles the response to the RecoverSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RecoverSlotResponder(resp *http.Response) (result RecoverResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ResetProductionSlotConfig resets the configuration settings of the current
+// slot if they were previously modified by calling the API with POST.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) ResetProductionSlotConfig(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ResetProductionSlotConfig")
+ }
+
+ req, err := client.ResetProductionSlotConfigPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ResetProductionSlotConfig", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ResetProductionSlotConfigSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ResetProductionSlotConfig", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ResetProductionSlotConfigResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ResetProductionSlotConfig", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ResetProductionSlotConfigPreparer prepares the ResetProductionSlotConfig request.
+func (client AppsClient) ResetProductionSlotConfigPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/resetSlotConfig", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ResetProductionSlotConfigSender sends the ResetProductionSlotConfig request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ResetProductionSlotConfigSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ResetProductionSlotConfigResponder handles the response to the ResetProductionSlotConfig request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ResetProductionSlotConfigResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// ResetSlotConfigurationSlot resets the configuration settings of the current
+// slot if they were previously modified by calling the API with POST.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API resets configuration settings for the
+// production slot.
+func (client AppsClient) ResetSlotConfigurationSlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "ResetSlotConfigurationSlot")
+ }
+
+ req, err := client.ResetSlotConfigurationSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ResetSlotConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ResetSlotConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ResetSlotConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ResetSlotConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "ResetSlotConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ResetSlotConfigurationSlotPreparer prepares the ResetSlotConfigurationSlot request.
+func (client AppsClient) ResetSlotConfigurationSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/resetSlotConfig", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ResetSlotConfigurationSlotSender sends the ResetSlotConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) ResetSlotConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ResetSlotConfigurationSlotResponder handles the response to the ResetSlotConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) ResetSlotConfigurationSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Restart restarts an app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. softRestart is specify true to apply the
+// configuration settings and restarts the app only if necessary. By default,
+// the API always restarts and reprovisions the app. synchronous is specify
+// true to block until the app is restarted. By default, it is set to false,
+// and the API responds immediately (asynchronous).
+func (client AppsClient) Restart(resourceGroupName string, name string, softRestart *bool, synchronous *bool) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "Restart")
+ }
+
+ req, err := client.RestartPreparer(resourceGroupName, name, softRestart, synchronous)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Restart", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RestartSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Restart", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RestartResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Restart", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RestartPreparer prepares the Restart request.
+func (client AppsClient) RestartPreparer(resourceGroupName string, name string, softRestart *bool, synchronous *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if softRestart != nil {
+ queryParameters["softRestart"] = autorest.Encode("query", *softRestart)
+ }
+ if synchronous != nil {
+ queryParameters["synchronous"] = autorest.Encode("query", *synchronous)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/restart", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RestartSender sends the Restart request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RestartSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RestartResponder handles the response to the Restart request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RestartResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// RestartSlot restarts an app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will restart the production slot. softRestart
+// is specify true to apply the configuration settings and restarts the app
+// only if necessary. By default, the API always restarts and reprovisions the
+// app. synchronous is specify true to block until the app is restarted. By
+// default, it is set to false, and the API responds immediately
+// (asynchronous).
+func (client AppsClient) RestartSlot(resourceGroupName string, name string, slot string, softRestart *bool, synchronous *bool) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "RestartSlot")
+ }
+
+ req, err := client.RestartSlotPreparer(resourceGroupName, name, slot, softRestart, synchronous)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RestartSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RestartSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RestartSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RestartSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RestartSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RestartSlotPreparer prepares the RestartSlot request.
+func (client AppsClient) RestartSlotPreparer(resourceGroupName string, name string, slot string, softRestart *bool, synchronous *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if softRestart != nil {
+ queryParameters["softRestart"] = autorest.Encode("query", *softRestart)
+ }
+ if synchronous != nil {
+ queryParameters["synchronous"] = autorest.Encode("query", *synchronous)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/restart", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RestartSlotSender sends the RestartSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RestartSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RestartSlotResponder handles the response to the RestartSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RestartSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Restore restores a specific backup to another app (or deployment slot, if
+// specified). This method may poll for completion. Polling can be canceled by
+// passing the cancel channel argument. The channel will be used to cancel
+// polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. backupID is iD of the backup. request is
+// information on restore request
+func (client AppsClient) Restore(resourceGroupName string, name string, backupID string, request RestoreRequest, cancel <-chan struct{}) (<-chan RestoreResponse, <-chan error) {
+ resultChan := make(chan RestoreResponse, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "Restore")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result RestoreResponse
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.RestorePreparer(resourceGroupName, name, backupID, request, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Restore", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RestoreSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Restore", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RestoreResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Restore", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// RestorePreparer prepares the Restore request.
+func (client AppsClient) RestorePreparer(resourceGroupName string, name string, backupID string, request RestoreRequest, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/backups/{backupId}/restore", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// RestoreSender sends the Restore request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RestoreSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// RestoreResponder handles the response to the Restore request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RestoreResponder(resp *http.Response) (result RestoreResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RestoreSlot restores a specific backup to another app (or deployment slot,
+// if specified). This method may poll for completion. Polling can be canceled
+// by passing the cancel channel argument. The channel will be used to cancel
+// polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. backupID is iD of the backup. request is
+// information on restore request slot is name of the deployment slot. If a
+// slot is not specified, the API will restore a backup of the production slot.
+func (client AppsClient) RestoreSlot(resourceGroupName string, name string, backupID string, request RestoreRequest, slot string, cancel <-chan struct{}) (<-chan RestoreResponse, <-chan error) {
+ resultChan := make(chan RestoreResponse, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "RestoreSlot")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result RestoreResponse
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.RestoreSlotPreparer(resourceGroupName, name, backupID, request, slot, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RestoreSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RestoreSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RestoreSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RestoreSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "RestoreSlot", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// RestoreSlotPreparer prepares the RestoreSlot request.
+func (client AppsClient) RestoreSlotPreparer(resourceGroupName string, name string, backupID string, request RestoreRequest, slot string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "backupId": autorest.Encode("path", backupID),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/backups/{backupId}/restore", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// RestoreSlotSender sends the RestoreSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) RestoreSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// RestoreSlotResponder handles the response to the RestoreSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) RestoreSlotResponder(resp *http.Response) (result RestoreResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Start starts an app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) Start(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "Start")
+ }
+
+ req, err := client.StartPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Start", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StartSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Start", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StartResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Start", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StartPreparer prepares the Start request.
+func (client AppsClient) StartPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StartSender sends the Start request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StartSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StartResponder handles the response to the Start request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StartResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// StartSlot starts an app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will start the production slot.
+func (client AppsClient) StartSlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "StartSlot")
+ }
+
+ req, err := client.StartSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StartSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StartSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StartSlotPreparer prepares the StartSlot request.
+func (client AppsClient) StartSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StartSlotSender sends the StartSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StartSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StartSlotResponder handles the response to the StartSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StartSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// StartWebSiteNetworkTrace start capturing network packets for the site.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app. durationInSeconds is the duration
+// to keep capturing in seconds. maxFrameLength is the maximum frame length in
+// bytes (Optional). sasURL is the Blob URL to store capture file.
+func (client AppsClient) StartWebSiteNetworkTrace(resourceGroupName string, name string, durationInSeconds *int32, maxFrameLength *int32, sasURL string) (result String, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "StartWebSiteNetworkTrace")
+ }
+
+ req, err := client.StartWebSiteNetworkTracePreparer(resourceGroupName, name, durationInSeconds, maxFrameLength, sasURL)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartWebSiteNetworkTrace", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StartWebSiteNetworkTraceSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartWebSiteNetworkTrace", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StartWebSiteNetworkTraceResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartWebSiteNetworkTrace", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StartWebSiteNetworkTracePreparer prepares the StartWebSiteNetworkTrace request.
+func (client AppsClient) StartWebSiteNetworkTracePreparer(resourceGroupName string, name string, durationInSeconds *int32, maxFrameLength *int32, sasURL string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if durationInSeconds != nil {
+ queryParameters["durationInSeconds"] = autorest.Encode("query", *durationInSeconds)
+ }
+ if maxFrameLength != nil {
+ queryParameters["maxFrameLength"] = autorest.Encode("query", *maxFrameLength)
+ }
+ if len(sasURL) > 0 {
+ queryParameters["sasUrl"] = autorest.Encode("query", sasURL)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/networkTrace/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StartWebSiteNetworkTraceSender sends the StartWebSiteNetworkTrace request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StartWebSiteNetworkTraceSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StartWebSiteNetworkTraceResponder handles the response to the StartWebSiteNetworkTrace request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StartWebSiteNetworkTraceResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// StartWebSiteNetworkTraceSlot start capturing network packets for the site.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app. slot is the name of the slot for
+// this web app. durationInSeconds is the duration to keep capturing in
+// seconds. maxFrameLength is the maximum frame length in bytes (Optional).
+// sasURL is the Blob URL to store capture file.
+func (client AppsClient) StartWebSiteNetworkTraceSlot(resourceGroupName string, name string, slot string, durationInSeconds *int32, maxFrameLength *int32, sasURL string) (result String, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "StartWebSiteNetworkTraceSlot")
+ }
+
+ req, err := client.StartWebSiteNetworkTraceSlotPreparer(resourceGroupName, name, slot, durationInSeconds, maxFrameLength, sasURL)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartWebSiteNetworkTraceSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StartWebSiteNetworkTraceSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartWebSiteNetworkTraceSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StartWebSiteNetworkTraceSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StartWebSiteNetworkTraceSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StartWebSiteNetworkTraceSlotPreparer prepares the StartWebSiteNetworkTraceSlot request.
+func (client AppsClient) StartWebSiteNetworkTraceSlotPreparer(resourceGroupName string, name string, slot string, durationInSeconds *int32, maxFrameLength *int32, sasURL string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if durationInSeconds != nil {
+ queryParameters["durationInSeconds"] = autorest.Encode("query", *durationInSeconds)
+ }
+ if maxFrameLength != nil {
+ queryParameters["maxFrameLength"] = autorest.Encode("query", *maxFrameLength)
+ }
+ if len(sasURL) > 0 {
+ queryParameters["sasUrl"] = autorest.Encode("query", sasURL)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/networkTrace/start", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StartWebSiteNetworkTraceSlotSender sends the StartWebSiteNetworkTraceSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StartWebSiteNetworkTraceSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StartWebSiteNetworkTraceSlotResponder handles the response to the StartWebSiteNetworkTraceSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StartWebSiteNetworkTraceSlotResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Stop stops an app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) Stop(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "Stop")
+ }
+
+ req, err := client.StopPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Stop", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StopSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Stop", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StopResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "Stop", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StopPreparer prepares the Stop request.
+func (client AppsClient) StopPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/stop", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StopSender sends the Stop request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StopSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StopResponder handles the response to the Stop request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StopResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// StopSlot stops an app (or deployment slot, if specified).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will stop the production slot.
+func (client AppsClient) StopSlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "StopSlot")
+ }
+
+ req, err := client.StopSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StopSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StopSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StopSlotPreparer prepares the StopSlot request.
+func (client AppsClient) StopSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/stop", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StopSlotSender sends the StopSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StopSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StopSlotResponder handles the response to the StopSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StopSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// StopWebSiteNetworkTrace stop ongoing capturing network packets for the site.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app.
+func (client AppsClient) StopWebSiteNetworkTrace(resourceGroupName string, name string) (result String, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "StopWebSiteNetworkTrace")
+ }
+
+ req, err := client.StopWebSiteNetworkTracePreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopWebSiteNetworkTrace", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StopWebSiteNetworkTraceSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopWebSiteNetworkTrace", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StopWebSiteNetworkTraceResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopWebSiteNetworkTrace", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StopWebSiteNetworkTracePreparer prepares the StopWebSiteNetworkTrace request.
+func (client AppsClient) StopWebSiteNetworkTracePreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/networkTrace/stop", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StopWebSiteNetworkTraceSender sends the StopWebSiteNetworkTrace request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StopWebSiteNetworkTraceSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StopWebSiteNetworkTraceResponder handles the response to the StopWebSiteNetworkTrace request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StopWebSiteNetworkTraceResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// StopWebSiteNetworkTraceSlot stop ongoing capturing network packets for the
+// site.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app. slot is the name of the slot for
+// this web app.
+func (client AppsClient) StopWebSiteNetworkTraceSlot(resourceGroupName string, name string, slot string) (result String, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "StopWebSiteNetworkTraceSlot")
+ }
+
+ req, err := client.StopWebSiteNetworkTraceSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopWebSiteNetworkTraceSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.StopWebSiteNetworkTraceSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopWebSiteNetworkTraceSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.StopWebSiteNetworkTraceSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "StopWebSiteNetworkTraceSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// StopWebSiteNetworkTraceSlotPreparer prepares the StopWebSiteNetworkTraceSlot request.
+func (client AppsClient) StopWebSiteNetworkTraceSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/networkTrace/stop", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// StopWebSiteNetworkTraceSlotSender sends the StopWebSiteNetworkTraceSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) StopWebSiteNetworkTraceSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// StopWebSiteNetworkTraceSlotResponder handles the response to the StopWebSiteNetworkTraceSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) StopWebSiteNetworkTraceSlotResponder(resp *http.Response) (result String, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// SwapSlotSlot swaps two deployment slots of an app. This method may poll for
+// completion. Polling can be canceled by passing the cancel channel argument.
+// The channel will be used to cancel polling and any outstanding HTTP
+// requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slotSwapEntity is jSON object that
+// contains the target slot name. See example. slot is name of the source slot.
+// If a slot is not specified, the production slot is used as the source slot.
+func (client AppsClient) SwapSlotSlot(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, slot string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
+ resultChan := make(chan autorest.Response, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: slotSwapEntity,
+ Constraints: []validation.Constraint{{Target: "slotSwapEntity.TargetSlot", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "slotSwapEntity.PreserveVnet", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "SwapSlotSlot")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result autorest.Response
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.SwapSlotSlotPreparer(resourceGroupName, name, slotSwapEntity, slot, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SwapSlotSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SwapSlotSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SwapSlotSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SwapSlotSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SwapSlotSlot", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// SwapSlotSlotPreparer prepares the SwapSlotSlot request.
+func (client AppsClient) SwapSlotSlotPreparer(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, slot string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/slotsswap", pathParameters),
+ autorest.WithJSON(slotSwapEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// SwapSlotSlotSender sends the SwapSlotSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) SwapSlotSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// SwapSlotSlotResponder handles the response to the SwapSlotSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) SwapSlotSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// SwapSlotWithProduction swaps two deployment slots of an app. This method may
+// poll for completion. Polling can be canceled by passing the cancel channel
+// argument. The channel will be used to cancel polling and any outstanding
+// HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slotSwapEntity is jSON object that
+// contains the target slot name. See example.
+func (client AppsClient) SwapSlotWithProduction(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
+ resultChan := make(chan autorest.Response, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: slotSwapEntity,
+ Constraints: []validation.Constraint{{Target: "slotSwapEntity.TargetSlot", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "slotSwapEntity.PreserveVnet", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppsClient", "SwapSlotWithProduction")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result autorest.Response
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.SwapSlotWithProductionPreparer(resourceGroupName, name, slotSwapEntity, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SwapSlotWithProduction", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SwapSlotWithProductionSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SwapSlotWithProduction", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SwapSlotWithProductionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SwapSlotWithProduction", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// SwapSlotWithProductionPreparer prepares the SwapSlotWithProduction request.
+func (client AppsClient) SwapSlotWithProductionPreparer(resourceGroupName string, name string, slotSwapEntity CsmSlotEntity, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slotsswap", pathParameters),
+ autorest.WithJSON(slotSwapEntity),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// SwapSlotWithProductionSender sends the SwapSlotWithProduction request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) SwapSlotWithProductionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// SwapSlotWithProductionResponder handles the response to the SwapSlotWithProduction request. The method always
+// closes the http.Response Body.
+func (client AppsClient) SwapSlotWithProductionResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// SyncFunctionTriggers syncs function trigger metadata to the scale controller
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app.
+func (client AppsClient) SyncFunctionTriggers(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "SyncFunctionTriggers")
+ }
+
+ req, err := client.SyncFunctionTriggersPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncFunctionTriggers", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SyncFunctionTriggersSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncFunctionTriggers", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SyncFunctionTriggersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncFunctionTriggers", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// SyncFunctionTriggersPreparer prepares the SyncFunctionTriggers request.
+func (client AppsClient) SyncFunctionTriggersPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/syncfunctiontriggers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// SyncFunctionTriggersSender sends the SyncFunctionTriggers request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) SyncFunctionTriggersSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// SyncFunctionTriggersResponder handles the response to the SyncFunctionTriggers request. The method always
+// closes the http.Response Body.
+func (client AppsClient) SyncFunctionTriggersResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// SyncFunctionTriggersSlot syncs function trigger metadata to the scale
+// controller
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slot is name of the deployment slot. If a
+// slot is not specified, the API will restore a backup of the production slot.
+func (client AppsClient) SyncFunctionTriggersSlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "SyncFunctionTriggersSlot")
+ }
+
+ req, err := client.SyncFunctionTriggersSlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncFunctionTriggersSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SyncFunctionTriggersSlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncFunctionTriggersSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SyncFunctionTriggersSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncFunctionTriggersSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// SyncFunctionTriggersSlotPreparer prepares the SyncFunctionTriggersSlot request.
+func (client AppsClient) SyncFunctionTriggersSlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/syncfunctiontriggers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// SyncFunctionTriggersSlotSender sends the SyncFunctionTriggersSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) SyncFunctionTriggersSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// SyncFunctionTriggersSlotResponder handles the response to the SyncFunctionTriggersSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) SyncFunctionTriggersSlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// SyncRepository sync web app repository.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app
+func (client AppsClient) SyncRepository(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "SyncRepository")
+ }
+
+ req, err := client.SyncRepositoryPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncRepository", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SyncRepositorySender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncRepository", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SyncRepositoryResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncRepository", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// SyncRepositoryPreparer prepares the SyncRepository request.
+func (client AppsClient) SyncRepositoryPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/sync", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// SyncRepositorySender sends the SyncRepository request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) SyncRepositorySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// SyncRepositoryResponder handles the response to the SyncRepository request. The method always
+// closes the http.Response Body.
+func (client AppsClient) SyncRepositoryResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// SyncRepositorySlot sync web app repository.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app slot is name of web app slot. If not
+// specified then will default to production slot.
+func (client AppsClient) SyncRepositorySlot(resourceGroupName string, name string, slot string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "SyncRepositorySlot")
+ }
+
+ req, err := client.SyncRepositorySlotPreparer(resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncRepositorySlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SyncRepositorySlotSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncRepositorySlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SyncRepositorySlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "SyncRepositorySlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// SyncRepositorySlotPreparer prepares the SyncRepositorySlot request.
+func (client AppsClient) SyncRepositorySlotPreparer(resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/sync", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// SyncRepositorySlotSender sends the SyncRepositorySlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) SyncRepositorySlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// SyncRepositorySlotResponder handles the response to the SyncRepositorySlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) SyncRepositorySlotResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// UpdateApplicationSettings replaces the application settings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. appSettings is application settings of the
+// app.
+func (client AppsClient) UpdateApplicationSettings(resourceGroupName string, name string, appSettings StringDictionary) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateApplicationSettings")
+ }
+
+ req, err := client.UpdateApplicationSettingsPreparer(resourceGroupName, name, appSettings)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateApplicationSettings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateApplicationSettingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateApplicationSettings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateApplicationSettingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateApplicationSettings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateApplicationSettingsPreparer prepares the UpdateApplicationSettings request.
+func (client AppsClient) UpdateApplicationSettingsPreparer(resourceGroupName string, name string, appSettings StringDictionary) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/appsettings", pathParameters),
+ autorest.WithJSON(appSettings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateApplicationSettingsSender sends the UpdateApplicationSettings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateApplicationSettingsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateApplicationSettingsResponder handles the response to the UpdateApplicationSettings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateApplicationSettingsResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateApplicationSettingsSlot replaces the application settings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. appSettings is application settings of the
+// app. slot is name of the deployment slot. If a slot is not specified, the
+// API will update the application settings for the production slot.
+func (client AppsClient) UpdateApplicationSettingsSlot(resourceGroupName string, name string, appSettings StringDictionary, slot string) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateApplicationSettingsSlot")
+ }
+
+ req, err := client.UpdateApplicationSettingsSlotPreparer(resourceGroupName, name, appSettings, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateApplicationSettingsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateApplicationSettingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateApplicationSettingsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateApplicationSettingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateApplicationSettingsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateApplicationSettingsSlotPreparer prepares the UpdateApplicationSettingsSlot request.
+func (client AppsClient) UpdateApplicationSettingsSlotPreparer(resourceGroupName string, name string, appSettings StringDictionary, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/appsettings", pathParameters),
+ autorest.WithJSON(appSettings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateApplicationSettingsSlotSender sends the UpdateApplicationSettingsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateApplicationSettingsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateApplicationSettingsSlotResponder handles the response to the UpdateApplicationSettingsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateApplicationSettingsSlotResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateAuthSettings updates the Authentication / Authorization settings
+// associated with web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app siteAuthSettings is auth settings
+// associated with web app
+func (client AppsClient) UpdateAuthSettings(resourceGroupName string, name string, siteAuthSettings SiteAuthSettings) (result SiteAuthSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateAuthSettings")
+ }
+
+ req, err := client.UpdateAuthSettingsPreparer(resourceGroupName, name, siteAuthSettings)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateAuthSettings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateAuthSettingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateAuthSettings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateAuthSettingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateAuthSettings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateAuthSettingsPreparer prepares the UpdateAuthSettings request.
+func (client AppsClient) UpdateAuthSettingsPreparer(resourceGroupName string, name string, siteAuthSettings SiteAuthSettings) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/authsettings", pathParameters),
+ autorest.WithJSON(siteAuthSettings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateAuthSettingsSender sends the UpdateAuthSettings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateAuthSettingsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateAuthSettingsResponder handles the response to the UpdateAuthSettings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateAuthSettingsResponder(resp *http.Response) (result SiteAuthSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateAuthSettingsSlot updates the Authentication / Authorization settings
+// associated with web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app siteAuthSettings is auth settings
+// associated with web app slot is name of web app slot. If not specified then
+// will default to production slot.
+func (client AppsClient) UpdateAuthSettingsSlot(resourceGroupName string, name string, siteAuthSettings SiteAuthSettings, slot string) (result SiteAuthSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateAuthSettingsSlot")
+ }
+
+ req, err := client.UpdateAuthSettingsSlotPreparer(resourceGroupName, name, siteAuthSettings, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateAuthSettingsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateAuthSettingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateAuthSettingsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateAuthSettingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateAuthSettingsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateAuthSettingsSlotPreparer prepares the UpdateAuthSettingsSlot request.
+func (client AppsClient) UpdateAuthSettingsSlotPreparer(resourceGroupName string, name string, siteAuthSettings SiteAuthSettings, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/authsettings", pathParameters),
+ autorest.WithJSON(siteAuthSettings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateAuthSettingsSlotSender sends the UpdateAuthSettingsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateAuthSettingsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateAuthSettingsSlotResponder handles the response to the UpdateAuthSettingsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateAuthSettingsSlotResponder(resp *http.Response) (result SiteAuthSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateBackupConfiguration updates the backup configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. request is edited backup configuration.
+func (client AppsClient) UpdateBackupConfiguration(resourceGroupName string, name string, request BackupRequest) (result BackupRequest, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: request,
+ Constraints: []validation.Constraint{{Target: "request.BackupRequestProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule.FrequencyInterval", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.KeepAtLeastOneBackup", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.RetentionPeriodInDays", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateBackupConfiguration")
+ }
+
+ req, err := client.UpdateBackupConfigurationPreparer(resourceGroupName, name, request)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateBackupConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateBackupConfigurationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateBackupConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateBackupConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateBackupConfiguration", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateBackupConfigurationPreparer prepares the UpdateBackupConfiguration request.
+func (client AppsClient) UpdateBackupConfigurationPreparer(resourceGroupName string, name string, request BackupRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/backup", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateBackupConfigurationSender sends the UpdateBackupConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateBackupConfigurationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateBackupConfigurationResponder handles the response to the UpdateBackupConfiguration request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateBackupConfigurationResponder(resp *http.Response) (result BackupRequest, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateBackupConfigurationSlot updates the backup configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. request is edited backup configuration.
+// slot is name of the deployment slot. If a slot is not specified, the API
+// will update the backup configuration for the production slot.
+func (client AppsClient) UpdateBackupConfigurationSlot(resourceGroupName string, name string, request BackupRequest, slot string) (result BackupRequest, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: request,
+ Constraints: []validation.Constraint{{Target: "request.BackupRequestProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "request.BackupRequestProperties.BackupSchedule.FrequencyInterval", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.KeepAtLeastOneBackup", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "request.BackupRequestProperties.BackupSchedule.RetentionPeriodInDays", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateBackupConfigurationSlot")
+ }
+
+ req, err := client.UpdateBackupConfigurationSlotPreparer(resourceGroupName, name, request, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateBackupConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateBackupConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateBackupConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateBackupConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateBackupConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateBackupConfigurationSlotPreparer prepares the UpdateBackupConfigurationSlot request.
+func (client AppsClient) UpdateBackupConfigurationSlotPreparer(resourceGroupName string, name string, request BackupRequest, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/backup", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateBackupConfigurationSlotSender sends the UpdateBackupConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateBackupConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateBackupConfigurationSlotResponder handles the response to the UpdateBackupConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateBackupConfigurationSlotResponder(resp *http.Response) (result BackupRequest, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateConfiguration updates the configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteConfig is jSON representation of a
+// SiteConfig object. See example.
+func (client AppsClient) UpdateConfiguration(resourceGroupName string, name string, siteConfig SiteConfigResource) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateConfiguration")
+ }
+
+ req, err := client.UpdateConfigurationPreparer(resourceGroupName, name, siteConfig)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConfiguration", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateConfigurationSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConfiguration", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateConfigurationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConfiguration", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateConfigurationPreparer prepares the UpdateConfiguration request.
+func (client AppsClient) UpdateConfigurationPreparer(resourceGroupName string, name string, siteConfig SiteConfigResource) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/web", pathParameters),
+ autorest.WithJSON(siteConfig),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateConfigurationSender sends the UpdateConfiguration request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateConfigurationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateConfigurationResponder handles the response to the UpdateConfiguration request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateConfigurationResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateConfigurationSlot updates the configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteConfig is jSON representation of a
+// SiteConfig object. See example. slot is name of the deployment slot. If a
+// slot is not specified, the API will update configuration for the production
+// slot.
+func (client AppsClient) UpdateConfigurationSlot(resourceGroupName string, name string, siteConfig SiteConfigResource, slot string) (result SiteConfigResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateConfigurationSlot")
+ }
+
+ req, err := client.UpdateConfigurationSlotPreparer(resourceGroupName, name, siteConfig, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConfigurationSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateConfigurationSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConfigurationSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateConfigurationSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConfigurationSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateConfigurationSlotPreparer prepares the UpdateConfigurationSlot request.
+func (client AppsClient) UpdateConfigurationSlotPreparer(resourceGroupName string, name string, siteConfig SiteConfigResource, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/web", pathParameters),
+ autorest.WithJSON(siteConfig),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateConfigurationSlotSender sends the UpdateConfigurationSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateConfigurationSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateConfigurationSlotResponder handles the response to the UpdateConfigurationSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateConfigurationSlotResponder(resp *http.Response) (result SiteConfigResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateConnectionStrings replaces the connection strings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. connectionStrings is connection strings of
+// the app or deployment slot. See example.
+func (client AppsClient) UpdateConnectionStrings(resourceGroupName string, name string, connectionStrings ConnectionStringDictionary) (result ConnectionStringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateConnectionStrings")
+ }
+
+ req, err := client.UpdateConnectionStringsPreparer(resourceGroupName, name, connectionStrings)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConnectionStrings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateConnectionStringsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConnectionStrings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateConnectionStringsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConnectionStrings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateConnectionStringsPreparer prepares the UpdateConnectionStrings request.
+func (client AppsClient) UpdateConnectionStringsPreparer(resourceGroupName string, name string, connectionStrings ConnectionStringDictionary) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/connectionstrings", pathParameters),
+ autorest.WithJSON(connectionStrings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateConnectionStringsSender sends the UpdateConnectionStrings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateConnectionStringsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateConnectionStringsResponder handles the response to the UpdateConnectionStrings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateConnectionStringsResponder(resp *http.Response) (result ConnectionStringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateConnectionStringsSlot replaces the connection strings of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. connectionStrings is connection strings of
+// the app or deployment slot. See example. slot is name of the deployment
+// slot. If a slot is not specified, the API will update the connection
+// settings for the production slot.
+func (client AppsClient) UpdateConnectionStringsSlot(resourceGroupName string, name string, connectionStrings ConnectionStringDictionary, slot string) (result ConnectionStringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateConnectionStringsSlot")
+ }
+
+ req, err := client.UpdateConnectionStringsSlotPreparer(resourceGroupName, name, connectionStrings, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConnectionStringsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateConnectionStringsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConnectionStringsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateConnectionStringsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateConnectionStringsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateConnectionStringsSlotPreparer prepares the UpdateConnectionStringsSlot request.
+func (client AppsClient) UpdateConnectionStringsSlotPreparer(resourceGroupName string, name string, connectionStrings ConnectionStringDictionary, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/connectionstrings", pathParameters),
+ autorest.WithJSON(connectionStrings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateConnectionStringsSlotSender sends the UpdateConnectionStringsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateConnectionStringsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateConnectionStringsSlotResponder handles the response to the UpdateConnectionStringsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateConnectionStringsSlotResponder(resp *http.Response) (result ConnectionStringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateDiagnosticLogsConfig updates the logging configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteLogsConfig is a SiteLogsConfig JSON
+// object that contains the logging configuration to change in the "properties"
+// property.
+func (client AppsClient) UpdateDiagnosticLogsConfig(resourceGroupName string, name string, siteLogsConfig SiteLogsConfig) (result SiteLogsConfig, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: siteLogsConfig,
+ Constraints: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.ApplicationLogs", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.ApplicationLogs.AzureTableStorage", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.ApplicationLogs.AzureTableStorage.SasURL", Name: validation.Null, Rule: true, Chain: nil}}},
+ }},
+ {Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem.RetentionInMb", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem.RetentionInMb", Name: validation.InclusiveMaximum, Rule: 100, Chain: nil},
+ {Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem.RetentionInMb", Name: validation.InclusiveMinimum, Rule: 25, Chain: nil},
+ }},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateDiagnosticLogsConfig")
+ }
+
+ req, err := client.UpdateDiagnosticLogsConfigPreparer(resourceGroupName, name, siteLogsConfig)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDiagnosticLogsConfig", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateDiagnosticLogsConfigSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDiagnosticLogsConfig", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateDiagnosticLogsConfigResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDiagnosticLogsConfig", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateDiagnosticLogsConfigPreparer prepares the UpdateDiagnosticLogsConfig request.
+func (client AppsClient) UpdateDiagnosticLogsConfigPreparer(resourceGroupName string, name string, siteLogsConfig SiteLogsConfig) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/logs", pathParameters),
+ autorest.WithJSON(siteLogsConfig),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateDiagnosticLogsConfigSender sends the UpdateDiagnosticLogsConfig request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateDiagnosticLogsConfigSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateDiagnosticLogsConfigResponder handles the response to the UpdateDiagnosticLogsConfig request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateDiagnosticLogsConfigResponder(resp *http.Response) (result SiteLogsConfig, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateDiagnosticLogsConfigSlot updates the logging configuration of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. siteLogsConfig is a SiteLogsConfig JSON
+// object that contains the logging configuration to change in the "properties"
+// property. slot is name of the deployment slot. If a slot is not specified,
+// the API will update the logging configuration for the production slot.
+func (client AppsClient) UpdateDiagnosticLogsConfigSlot(resourceGroupName string, name string, siteLogsConfig SiteLogsConfig, slot string) (result SiteLogsConfig, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: siteLogsConfig,
+ Constraints: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.ApplicationLogs", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.ApplicationLogs.AzureTableStorage", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.ApplicationLogs.AzureTableStorage.SasURL", Name: validation.Null, Rule: true, Chain: nil}}},
+ }},
+ {Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem.RetentionInMb", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem.RetentionInMb", Name: validation.InclusiveMaximum, Rule: 100, Chain: nil},
+ {Target: "siteLogsConfig.SiteLogsConfigProperties.HTTPLogs.FileSystem.RetentionInMb", Name: validation.InclusiveMinimum, Rule: 25, Chain: nil},
+ }},
+ }},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateDiagnosticLogsConfigSlot")
+ }
+
+ req, err := client.UpdateDiagnosticLogsConfigSlotPreparer(resourceGroupName, name, siteLogsConfig, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDiagnosticLogsConfigSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateDiagnosticLogsConfigSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDiagnosticLogsConfigSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateDiagnosticLogsConfigSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDiagnosticLogsConfigSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateDiagnosticLogsConfigSlotPreparer prepares the UpdateDiagnosticLogsConfigSlot request.
+func (client AppsClient) UpdateDiagnosticLogsConfigSlotPreparer(resourceGroupName string, name string, siteLogsConfig SiteLogsConfig, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/logs", pathParameters),
+ autorest.WithJSON(siteLogsConfig),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateDiagnosticLogsConfigSlotSender sends the UpdateDiagnosticLogsConfigSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateDiagnosticLogsConfigSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateDiagnosticLogsConfigSlotResponder handles the response to the UpdateDiagnosticLogsConfigSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateDiagnosticLogsConfigSlotResponder(resp *http.Response) (result SiteLogsConfig, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateDomainOwnershipIdentifier creates a domain ownership identifier for
+// web app, or updates an existing ownership identifier.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier. domainOwnershipIdentifier is a JSON
+// representation of the domain ownership properties.
+func (client AppsClient) UpdateDomainOwnershipIdentifier(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier) (result Identifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifier")
+ }
+
+ req, err := client.UpdateDomainOwnershipIdentifierPreparer(resourceGroupName, name, domainOwnershipIdentifierName, domainOwnershipIdentifier)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateDomainOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateDomainOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateDomainOwnershipIdentifierPreparer prepares the UpdateDomainOwnershipIdentifier request.
+func (client AppsClient) UpdateDomainOwnershipIdentifierPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithJSON(domainOwnershipIdentifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateDomainOwnershipIdentifierSender sends the UpdateDomainOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateDomainOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateDomainOwnershipIdentifierResponder handles the response to the UpdateDomainOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateDomainOwnershipIdentifierResponder(resp *http.Response) (result Identifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateDomainOwnershipIdentifierSlot creates a domain ownership identifier
+// for web app, or updates an existing ownership identifier.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. domainOwnershipIdentifierName is name of
+// domain ownership identifier. domainOwnershipIdentifier is a JSON
+// representation of the domain ownership properties. slot is name of the
+// deployment slot. If a slot is not specified, the API will delete the binding
+// for the production slot.
+func (client AppsClient) UpdateDomainOwnershipIdentifierSlot(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier, slot string) (result Identifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifierSlot")
+ }
+
+ req, err := client.UpdateDomainOwnershipIdentifierSlotPreparer(resourceGroupName, name, domainOwnershipIdentifierName, domainOwnershipIdentifier, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifierSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateDomainOwnershipIdentifierSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifierSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateDomainOwnershipIdentifierSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateDomainOwnershipIdentifierSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateDomainOwnershipIdentifierSlotPreparer prepares the UpdateDomainOwnershipIdentifierSlot request.
+func (client AppsClient) UpdateDomainOwnershipIdentifierSlotPreparer(resourceGroupName string, name string, domainOwnershipIdentifierName string, domainOwnershipIdentifier Identifier, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainOwnershipIdentifierName": autorest.Encode("path", domainOwnershipIdentifierName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/domainOwnershipIdentifiers/{domainOwnershipIdentifierName}", pathParameters),
+ autorest.WithJSON(domainOwnershipIdentifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateDomainOwnershipIdentifierSlotSender sends the UpdateDomainOwnershipIdentifierSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateDomainOwnershipIdentifierSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateDomainOwnershipIdentifierSlotResponder handles the response to the UpdateDomainOwnershipIdentifierSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateDomainOwnershipIdentifierSlotResponder(resp *http.Response) (result Identifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateHybridConnection creates a new Hybrid Connection using a Service Bus
+// relay.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection connectionEnvelope is the details of the hybrid connection
+func (client AppsClient) UpdateHybridConnection(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateHybridConnection")
+ }
+
+ req, err := client.UpdateHybridConnectionPreparer(resourceGroupName, name, namespaceName, relayName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateHybridConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateHybridConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateHybridConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateHybridConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateHybridConnectionPreparer prepares the UpdateHybridConnection request.
+func (client AppsClient) UpdateHybridConnectionPreparer(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateHybridConnectionSender sends the UpdateHybridConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateHybridConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateHybridConnectionResponder handles the response to the UpdateHybridConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateHybridConnectionResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateHybridConnectionSlot creates a new Hybrid Connection using a Service
+// Bus relay.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is the name of the web app namespaceName is the namespace for
+// this hybrid connection relayName is the relay name for this hybrid
+// connection connectionEnvelope is the details of the hybrid connection slot
+// is the name of the slot for the web app.
+func (client AppsClient) UpdateHybridConnectionSlot(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection, slot string) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateHybridConnectionSlot")
+ }
+
+ req, err := client.UpdateHybridConnectionSlotPreparer(resourceGroupName, name, namespaceName, relayName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateHybridConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateHybridConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateHybridConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateHybridConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateHybridConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateHybridConnectionSlotPreparer prepares the UpdateHybridConnectionSlot request.
+func (client AppsClient) UpdateHybridConnectionSlotPreparer(resourceGroupName string, name string, namespaceName string, relayName string, connectionEnvelope HybridConnection, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateHybridConnectionSlotSender sends the UpdateHybridConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateHybridConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateHybridConnectionSlotResponder handles the response to the UpdateHybridConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateHybridConnectionSlotResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateMetadata replaces the metadata of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. metadata is edited metadata of the app or
+// deployment slot. See example.
+func (client AppsClient) UpdateMetadata(resourceGroupName string, name string, metadata StringDictionary) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateMetadata")
+ }
+
+ req, err := client.UpdateMetadataPreparer(resourceGroupName, name, metadata)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateMetadata", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateMetadataSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateMetadata", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateMetadataResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateMetadata", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateMetadataPreparer prepares the UpdateMetadata request.
+func (client AppsClient) UpdateMetadataPreparer(resourceGroupName string, name string, metadata StringDictionary) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/metadata", pathParameters),
+ autorest.WithJSON(metadata),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateMetadataSender sends the UpdateMetadata request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateMetadataSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateMetadataResponder handles the response to the UpdateMetadata request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateMetadataResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateMetadataSlot replaces the metadata of an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. metadata is edited metadata of the app or
+// deployment slot. See example. slot is name of the deployment slot. If a slot
+// is not specified, the API will update the metadata for the production slot.
+func (client AppsClient) UpdateMetadataSlot(resourceGroupName string, name string, metadata StringDictionary, slot string) (result StringDictionary, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateMetadataSlot")
+ }
+
+ req, err := client.UpdateMetadataSlotPreparer(resourceGroupName, name, metadata, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateMetadataSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateMetadataSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateMetadataSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateMetadataSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateMetadataSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateMetadataSlotPreparer prepares the UpdateMetadataSlot request.
+func (client AppsClient) UpdateMetadataSlotPreparer(resourceGroupName string, name string, metadata StringDictionary, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/metadata", pathParameters),
+ autorest.WithJSON(metadata),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateMetadataSlotSender sends the UpdateMetadataSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateMetadataSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateMetadataSlotResponder handles the response to the UpdateMetadataSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateMetadataSlotResponder(resp *http.Response) (result StringDictionary, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateRelayServiceConnection creates a new hybrid connection configuration
+// (PUT), or updates an existing one (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection configuration. connectionEnvelope is details of the hybrid
+// connection configuration.
+func (client AppsClient) UpdateRelayServiceConnection(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateRelayServiceConnection")
+ }
+
+ req, err := client.UpdateRelayServiceConnectionPreparer(resourceGroupName, name, entityName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateRelayServiceConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateRelayServiceConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateRelayServiceConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateRelayServiceConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateRelayServiceConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateRelayServiceConnectionPreparer prepares the UpdateRelayServiceConnection request.
+func (client AppsClient) UpdateRelayServiceConnectionPreparer(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateRelayServiceConnectionSender sends the UpdateRelayServiceConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateRelayServiceConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateRelayServiceConnectionResponder handles the response to the UpdateRelayServiceConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateRelayServiceConnectionResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateRelayServiceConnectionSlot creates a new hybrid connection
+// configuration (PUT), or updates an existing one (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. entityName is name of the hybrid
+// connection configuration. connectionEnvelope is details of the hybrid
+// connection configuration. slot is name of the deployment slot. If a slot is
+// not specified, the API will create or update a hybrid connection for the
+// production slot.
+func (client AppsClient) UpdateRelayServiceConnectionSlot(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity, slot string) (result RelayServiceConnectionEntity, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateRelayServiceConnectionSlot")
+ }
+
+ req, err := client.UpdateRelayServiceConnectionSlotPreparer(resourceGroupName, name, entityName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateRelayServiceConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateRelayServiceConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateRelayServiceConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateRelayServiceConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateRelayServiceConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateRelayServiceConnectionSlotPreparer prepares the UpdateRelayServiceConnectionSlot request.
+func (client AppsClient) UpdateRelayServiceConnectionSlotPreparer(resourceGroupName string, name string, entityName string, connectionEnvelope RelayServiceConnectionEntity, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "entityName": autorest.Encode("path", entityName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/hybridconnection/{entityName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateRelayServiceConnectionSlotSender sends the UpdateRelayServiceConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateRelayServiceConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateRelayServiceConnectionSlotResponder handles the response to the UpdateRelayServiceConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateRelayServiceConnectionSlotResponder(resp *http.Response) (result RelayServiceConnectionEntity, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateSitePushSettings updates the Push settings associated with web app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app pushSettings is push settings associated
+// with web app
+func (client AppsClient) UpdateSitePushSettings(resourceGroupName string, name string, pushSettings PushSettings) (result PushSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: pushSettings,
+ Constraints: []validation.Constraint{{Target: "pushSettings.IsPushEnabled", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateSitePushSettings")
+ }
+
+ req, err := client.UpdateSitePushSettingsPreparer(resourceGroupName, name, pushSettings)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSitePushSettings", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSitePushSettingsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSitePushSettings", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateSitePushSettingsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSitePushSettings", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateSitePushSettingsPreparer prepares the UpdateSitePushSettings request.
+func (client AppsClient) UpdateSitePushSettingsPreparer(resourceGroupName string, name string, pushSettings PushSettings) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/pushsettings", pathParameters),
+ autorest.WithJSON(pushSettings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateSitePushSettingsSender sends the UpdateSitePushSettings request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateSitePushSettingsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateSitePushSettingsResponder handles the response to the UpdateSitePushSettings request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateSitePushSettingsResponder(resp *http.Response) (result PushSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateSitePushSettingsSlot updates the Push settings associated with web
+// app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of web app pushSettings is push settings associated
+// with web app slot is name of web app slot. If not specified then will
+// default to production slot.
+func (client AppsClient) UpdateSitePushSettingsSlot(resourceGroupName string, name string, pushSettings PushSettings, slot string) (result PushSettings, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: pushSettings,
+ Constraints: []validation.Constraint{{Target: "pushSettings.IsPushEnabled", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateSitePushSettingsSlot")
+ }
+
+ req, err := client.UpdateSitePushSettingsSlotPreparer(resourceGroupName, name, pushSettings, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSitePushSettingsSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSitePushSettingsSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSitePushSettingsSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateSitePushSettingsSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSitePushSettingsSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateSitePushSettingsSlotPreparer prepares the UpdateSitePushSettingsSlot request.
+func (client AppsClient) UpdateSitePushSettingsSlotPreparer(resourceGroupName string, name string, pushSettings PushSettings, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/config/pushsettings", pathParameters),
+ autorest.WithJSON(pushSettings),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateSitePushSettingsSlotSender sends the UpdateSitePushSettingsSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateSitePushSettingsSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateSitePushSettingsSlotResponder handles the response to the UpdateSitePushSettingsSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateSitePushSettingsSlotResponder(resp *http.Response) (result PushSettings, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateSlotConfigurationNames updates the names of application settings and
+// connection string that remain with the slot during swap operation.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. slotConfigNames is names of application
+// settings and connection strings. See example.
+func (client AppsClient) UpdateSlotConfigurationNames(resourceGroupName string, name string, slotConfigNames SlotConfigNamesResource) (result SlotConfigNamesResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateSlotConfigurationNames")
+ }
+
+ req, err := client.UpdateSlotConfigurationNamesPreparer(resourceGroupName, name, slotConfigNames)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSlotConfigurationNames", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSlotConfigurationNamesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSlotConfigurationNames", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateSlotConfigurationNamesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateSlotConfigurationNames", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateSlotConfigurationNamesPreparer prepares the UpdateSlotConfigurationNames request.
+func (client AppsClient) UpdateSlotConfigurationNamesPreparer(resourceGroupName string, name string, slotConfigNames SlotConfigNamesResource) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/config/slotConfigNames", pathParameters),
+ autorest.WithJSON(slotConfigNames),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateSlotConfigurationNamesSender sends the UpdateSlotConfigurationNames request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateSlotConfigurationNamesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateSlotConfigurationNamesResponder handles the response to the UpdateSlotConfigurationNames request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateSlotConfigurationNamesResponder(resp *http.Response) (result SlotConfigNamesResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateVnetConnection adds a Virtual Network connection to an app or slot
+// (PUT) or updates the connection properties (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of an existing Virtual
+// Network. connectionEnvelope is properties of the Virtual Network connection.
+// See example.
+func (client AppsClient) UpdateVnetConnection(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo) (result VnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateVnetConnection")
+ }
+
+ req, err := client.UpdateVnetConnectionPreparer(resourceGroupName, name, vnetName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateVnetConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateVnetConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateVnetConnectionPreparer prepares the UpdateVnetConnection request.
+func (client AppsClient) UpdateVnetConnectionPreparer(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateVnetConnectionSender sends the UpdateVnetConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateVnetConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateVnetConnectionResponder handles the response to the UpdateVnetConnection request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateVnetConnectionResponder(resp *http.Response) (result VnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateVnetConnectionGateway adds a gateway to a connected Virtual Network
+// (PUT) or updates it (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the Virtual Network.
+// gatewayName is name of the gateway. Currently, the only supported string is
+// "primary". connectionEnvelope is the properties to update this gateway with.
+func (client AppsClient) UpdateVnetConnectionGateway(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateVnetConnectionGateway")
+ }
+
+ req, err := client.UpdateVnetConnectionGatewayPreparer(resourceGroupName, name, vnetName, gatewayName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionGateway", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateVnetConnectionGatewaySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionGateway", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateVnetConnectionGatewayResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionGateway", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateVnetConnectionGatewayPreparer prepares the UpdateVnetConnectionGateway request.
+func (client AppsClient) UpdateVnetConnectionGatewayPreparer(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateVnetConnectionGatewaySender sends the UpdateVnetConnectionGateway request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateVnetConnectionGatewaySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateVnetConnectionGatewayResponder handles the response to the UpdateVnetConnectionGateway request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateVnetConnectionGatewayResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateVnetConnectionGatewaySlot adds a gateway to a connected Virtual
+// Network (PUT) or updates it (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of the Virtual Network.
+// gatewayName is name of the gateway. Currently, the only supported string is
+// "primary". connectionEnvelope is the properties to update this gateway with.
+// slot is name of the deployment slot. If a slot is not specified, the API
+// will add or update a gateway for the production slot's Virtual Network.
+func (client AppsClient) UpdateVnetConnectionGatewaySlot(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway, slot string) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateVnetConnectionGatewaySlot")
+ }
+
+ req, err := client.UpdateVnetConnectionGatewaySlotPreparer(resourceGroupName, name, vnetName, gatewayName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionGatewaySlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateVnetConnectionGatewaySlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionGatewaySlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateVnetConnectionGatewaySlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionGatewaySlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateVnetConnectionGatewaySlotPreparer prepares the UpdateVnetConnectionGatewaySlot request.
+func (client AppsClient) UpdateVnetConnectionGatewaySlotPreparer(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateVnetConnectionGatewaySlotSender sends the UpdateVnetConnectionGatewaySlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateVnetConnectionGatewaySlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateVnetConnectionGatewaySlotResponder handles the response to the UpdateVnetConnectionGatewaySlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateVnetConnectionGatewaySlotResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateVnetConnectionSlot adds a Virtual Network connection to an app or slot
+// (PUT) or updates the connection properties (PATCH).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the app. vnetName is name of an existing Virtual
+// Network. connectionEnvelope is properties of the Virtual Network connection.
+// See example. slot is name of the deployment slot. If a slot is not
+// specified, the API will add or update connections for the production slot.
+func (client AppsClient) UpdateVnetConnectionSlot(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo, slot string) (result VnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppsClient", "UpdateVnetConnectionSlot")
+ }
+
+ req, err := client.UpdateVnetConnectionSlotPreparer(resourceGroupName, name, vnetName, connectionEnvelope, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateVnetConnectionSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateVnetConnectionSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppsClient", "UpdateVnetConnectionSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateVnetConnectionSlotPreparer prepares the UpdateVnetConnectionSlot request.
+func (client AppsClient) UpdateVnetConnectionSlotPreparer(resourceGroupName string, name string, vnetName string, connectionEnvelope VnetInfo, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateVnetConnectionSlotSender sends the UpdateVnetConnectionSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppsClient) UpdateVnetConnectionSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateVnetConnectionSlotResponder handles the response to the UpdateVnetConnectionSlot request. The method always
+// closes the http.Response Body.
+func (client AppsClient) UpdateVnetConnectionSlotResponder(resp *http.Response) (result VnetInfo, 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/Azure/azure-sdk-for-go/arm/web/appservicecertificateorders.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appservicecertificateorders.go
new file mode 100755
index 000000000000..c6a681b095be
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appservicecertificateorders.go
@@ -0,0 +1,1499 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// AppServiceCertificateOrdersClient is the composite Swagger for WebSite
+// Management Client
+type AppServiceCertificateOrdersClient struct {
+ ManagementClient
+}
+
+// NewAppServiceCertificateOrdersClient creates an instance of the
+// AppServiceCertificateOrdersClient client.
+func NewAppServiceCertificateOrdersClient(subscriptionID string) AppServiceCertificateOrdersClient {
+ return NewAppServiceCertificateOrdersClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewAppServiceCertificateOrdersClientWithBaseURI creates an instance of the
+// AppServiceCertificateOrdersClient client.
+func NewAppServiceCertificateOrdersClientWithBaseURI(baseURI string, subscriptionID string) AppServiceCertificateOrdersClient {
+ return AppServiceCertificateOrdersClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or update a certificate purchase order. This method
+// may poll for completion. Polling can be canceled by passing the cancel
+// channel argument. The channel will be used to cancel polling and any
+// outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+// certificateDistinguishedName is distinguished name to to use for the
+// certificate order.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdate(resourceGroupName string, certificateOrderName string, certificateDistinguishedName AppServiceCertificateOrder, cancel <-chan struct{}) (<-chan AppServiceCertificateOrder, <-chan error) {
+ resultChan := make(chan AppServiceCertificateOrder, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: certificateDistinguishedName,
+ Constraints: []validation.Constraint{{Target: "certificateDistinguishedName.AppServiceCertificateOrderProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "certificateDistinguishedName.AppServiceCertificateOrderProperties.ValidityInYears", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "certificateDistinguishedName.AppServiceCertificateOrderProperties.ValidityInYears", Name: validation.InclusiveMaximum, Rule: 3, Chain: nil},
+ {Target: "certificateDistinguishedName.AppServiceCertificateOrderProperties.ValidityInYears", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdate")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result AppServiceCertificateOrder
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdatePreparer(resourceGroupName, certificateOrderName, certificateDistinguishedName, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdatePreparer(resourceGroupName string, certificateOrderName string, certificateDistinguishedName AppServiceCertificateOrder, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}", pathParameters),
+ autorest.WithJSON(certificateDistinguishedName),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdateResponder(resp *http.Response) (result AppServiceCertificateOrder, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateCertificate creates or updates a certificate and associates
+// with key vault secret. This method may poll for completion. Polling can be
+// canceled by passing the cancel channel argument. The channel will be used to
+// cancel polling and any outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order. name is name
+// of the certificate. keyVaultCertificate is key vault certificate resource
+// Id.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdateCertificate(resourceGroupName string, certificateOrderName string, name string, keyVaultCertificate AppServiceCertificateResource, cancel <-chan struct{}) (<-chan AppServiceCertificateResource, <-chan error) {
+ resultChan := make(chan AppServiceCertificateResource, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdateCertificate")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result AppServiceCertificateResource
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdateCertificatePreparer(resourceGroupName, certificateOrderName, name, keyVaultCertificate, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdateCertificate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateCertificateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdateCertificate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateCertificateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "CreateOrUpdateCertificate", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdateCertificatePreparer prepares the CreateOrUpdateCertificate request.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdateCertificatePreparer(resourceGroupName string, certificateOrderName string, name string, keyVaultCertificate AppServiceCertificateResource, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}", pathParameters),
+ autorest.WithJSON(keyVaultCertificate),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateCertificateSender sends the CreateOrUpdateCertificate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdateCertificateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateCertificateResponder handles the response to the CreateOrUpdateCertificate request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) CreateOrUpdateCertificateResponder(resp *http.Response) (result AppServiceCertificateResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete delete an existing certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+func (client AppServiceCertificateOrdersClient) Delete(resourceGroupName string, certificateOrderName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "Delete")
+ }
+
+ req, err := client.DeletePreparer(resourceGroupName, certificateOrderName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Delete", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client AppServiceCertificateOrdersClient) DeletePreparer(resourceGroupName string, certificateOrderName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteCertificate delete the certificate associated with a certificate
+// order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order. name is name
+// of the certificate.
+func (client AppServiceCertificateOrdersClient) DeleteCertificate(resourceGroupName string, certificateOrderName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "DeleteCertificate")
+ }
+
+ req, err := client.DeleteCertificatePreparer(resourceGroupName, certificateOrderName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "DeleteCertificate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteCertificateSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "DeleteCertificate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteCertificateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "DeleteCertificate", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteCertificatePreparer prepares the DeleteCertificate request.
+func (client AppServiceCertificateOrdersClient) DeleteCertificatePreparer(resourceGroupName string, certificateOrderName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteCertificateSender sends the DeleteCertificate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) DeleteCertificateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteCertificateResponder handles the response to the DeleteCertificate request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) DeleteCertificateResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get get a certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order..
+func (client AppServiceCertificateOrdersClient) Get(resourceGroupName string, certificateOrderName string) (result AppServiceCertificateOrder, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "Get")
+ }
+
+ req, err := client.GetPreparer(resourceGroupName, certificateOrderName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client AppServiceCertificateOrdersClient) GetPreparer(resourceGroupName string, certificateOrderName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) GetResponder(resp *http.Response) (result AppServiceCertificateOrder, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetCertificate get the certificate associated with a certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order. name is name
+// of the certificate.
+func (client AppServiceCertificateOrdersClient) GetCertificate(resourceGroupName string, certificateOrderName string, name string) (result AppServiceCertificateResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "GetCertificate")
+ }
+
+ req, err := client.GetCertificatePreparer(resourceGroupName, certificateOrderName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "GetCertificate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetCertificateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "GetCertificate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetCertificateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "GetCertificate", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetCertificatePreparer prepares the GetCertificate request.
+func (client AppServiceCertificateOrdersClient) GetCertificatePreparer(resourceGroupName string, certificateOrderName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetCertificateSender sends the GetCertificate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) GetCertificateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetCertificateResponder handles the response to the GetCertificate request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) GetCertificateResponder(resp *http.Response) (result AppServiceCertificateResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List list all certificate orders in a subscription.
+func (client AppServiceCertificateOrdersClient) List() (result AppServiceCertificateOrderCollection, err error) {
+ req, err := client.ListPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client AppServiceCertificateOrdersClient) ListPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.CertificateRegistration/certificateOrders", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) ListResponder(resp *http.Response) (result AppServiceCertificateOrderCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 AppServiceCertificateOrdersClient) ListNextResults(lastResults AppServiceCertificateOrderCollection) (result AppServiceCertificateOrderCollection, err error) {
+ req, err := lastResults.AppServiceCertificateOrderCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "List", 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, "web.AppServiceCertificateOrdersClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListByResourceGroup get certificate orders in a resource group.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs.
+func (client AppServiceCertificateOrdersClient) ListByResourceGroup(resourceGroupName string) (result AppServiceCertificateOrderCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "ListByResourceGroup")
+ }
+
+ req, err := client.ListByResourceGroupPreparer(resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client AppServiceCertificateOrdersClient) ListByResourceGroupPreparer(resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) ListByResourceGroupResponder(resp *http.Response) (result AppServiceCertificateOrderCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client AppServiceCertificateOrdersClient) ListByResourceGroupNextResults(lastResults AppServiceCertificateOrderCollection) (result AppServiceCertificateOrderCollection, err error) {
+ req, err := lastResults.AppServiceCertificateOrderCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListByResourceGroup", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListCertificates list all certificates associated with a certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+func (client AppServiceCertificateOrdersClient) ListCertificates(resourceGroupName string, certificateOrderName string) (result AppServiceCertificateCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "ListCertificates")
+ }
+
+ req, err := client.ListCertificatesPreparer(resourceGroupName, certificateOrderName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListCertificates", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListCertificatesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListCertificates", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListCertificatesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListCertificates", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListCertificatesPreparer prepares the ListCertificates request.
+func (client AppServiceCertificateOrdersClient) ListCertificatesPreparer(resourceGroupName string, certificateOrderName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/certificates", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListCertificatesSender sends the ListCertificates request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) ListCertificatesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListCertificatesResponder handles the response to the ListCertificates request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) ListCertificatesResponder(resp *http.Response) (result AppServiceCertificateCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListCertificatesNextResults retrieves the next set of results, if any.
+func (client AppServiceCertificateOrdersClient) ListCertificatesNextResults(lastResults AppServiceCertificateCollection) (result AppServiceCertificateCollection, err error) {
+ req, err := lastResults.AppServiceCertificateCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListCertificates", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListCertificatesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListCertificates", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListCertificatesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ListCertificates", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// Reissue reissue an existing certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+// reissueCertificateOrderRequest is parameters for the reissue.
+func (client AppServiceCertificateOrdersClient) Reissue(resourceGroupName string, certificateOrderName string, reissueCertificateOrderRequest ReissueCertificateOrderRequest) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "Reissue")
+ }
+
+ req, err := client.ReissuePreparer(resourceGroupName, certificateOrderName, reissueCertificateOrderRequest)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Reissue", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ReissueSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Reissue", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ReissueResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Reissue", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ReissuePreparer prepares the Reissue request.
+func (client AppServiceCertificateOrdersClient) ReissuePreparer(resourceGroupName string, certificateOrderName string, reissueCertificateOrderRequest ReissueCertificateOrderRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/reissue", pathParameters),
+ autorest.WithJSON(reissueCertificateOrderRequest),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ReissueSender sends the Reissue request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) ReissueSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ReissueResponder handles the response to the Reissue request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) ReissueResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Renew renew an existing certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+// renewCertificateOrderRequest is renew parameters
+func (client AppServiceCertificateOrdersClient) Renew(resourceGroupName string, certificateOrderName string, renewCertificateOrderRequest RenewCertificateOrderRequest) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "Renew")
+ }
+
+ req, err := client.RenewPreparer(resourceGroupName, certificateOrderName, renewCertificateOrderRequest)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Renew", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RenewSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Renew", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RenewResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "Renew", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RenewPreparer prepares the Renew request.
+func (client AppServiceCertificateOrdersClient) RenewPreparer(resourceGroupName string, certificateOrderName string, renewCertificateOrderRequest RenewCertificateOrderRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/renew", pathParameters),
+ autorest.WithJSON(renewCertificateOrderRequest),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RenewSender sends the Renew request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) RenewSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RenewResponder handles the response to the Renew request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) RenewResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// ResendEmail resend certificate email.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+func (client AppServiceCertificateOrdersClient) ResendEmail(resourceGroupName string, certificateOrderName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "ResendEmail")
+ }
+
+ req, err := client.ResendEmailPreparer(resourceGroupName, certificateOrderName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ResendEmail", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ResendEmailSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ResendEmail", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ResendEmailResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ResendEmail", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ResendEmailPreparer prepares the ResendEmail request.
+func (client AppServiceCertificateOrdersClient) ResendEmailPreparer(resourceGroupName string, certificateOrderName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/resendEmail", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ResendEmailSender sends the ResendEmail request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) ResendEmailSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ResendEmailResponder handles the response to the ResendEmail request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) ResendEmailResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// ResendRequestEmails verify domain ownership for this certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+// nameIdentifier is email address
+func (client AppServiceCertificateOrdersClient) ResendRequestEmails(resourceGroupName string, certificateOrderName string, nameIdentifier NameIdentifier) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "ResendRequestEmails")
+ }
+
+ req, err := client.ResendRequestEmailsPreparer(resourceGroupName, certificateOrderName, nameIdentifier)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ResendRequestEmails", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ResendRequestEmailsSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ResendRequestEmails", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ResendRequestEmailsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ResendRequestEmails", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ResendRequestEmailsPreparer prepares the ResendRequestEmails request.
+func (client AppServiceCertificateOrdersClient) ResendRequestEmailsPreparer(resourceGroupName string, certificateOrderName string, nameIdentifier NameIdentifier) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/resendRequestEmails", pathParameters),
+ autorest.WithJSON(nameIdentifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ResendRequestEmailsSender sends the ResendRequestEmails request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) ResendRequestEmailsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ResendRequestEmailsResponder handles the response to the ResendRequestEmails request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) ResendRequestEmailsResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// RetrieveCertificateActions retrieve the list of certificate actions.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the certificate order.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateActions(resourceGroupName string, name string) (result ListCertificateOrderAction, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateActions")
+ }
+
+ req, err := client.RetrieveCertificateActionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateActions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RetrieveCertificateActionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateActions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RetrieveCertificateActionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateActions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RetrieveCertificateActionsPreparer prepares the RetrieveCertificateActions request.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateActionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{name}/retrieveCertificateActions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RetrieveCertificateActionsSender sends the RetrieveCertificateActions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateActionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RetrieveCertificateActionsResponder handles the response to the RetrieveCertificateActions request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateActionsResponder(resp *http.Response) (result ListCertificateOrderAction, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RetrieveCertificateEmailHistory retrieve email history.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the certificate order.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateEmailHistory(resourceGroupName string, name string) (result ListCertificateEmail, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateEmailHistory")
+ }
+
+ req, err := client.RetrieveCertificateEmailHistoryPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateEmailHistory", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RetrieveCertificateEmailHistorySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateEmailHistory", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RetrieveCertificateEmailHistoryResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveCertificateEmailHistory", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RetrieveCertificateEmailHistoryPreparer prepares the RetrieveCertificateEmailHistory request.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateEmailHistoryPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{name}/retrieveEmailHistory", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RetrieveCertificateEmailHistorySender sends the RetrieveCertificateEmailHistory request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateEmailHistorySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RetrieveCertificateEmailHistoryResponder handles the response to the RetrieveCertificateEmailHistory request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) RetrieveCertificateEmailHistoryResponder(resp *http.Response) (result ListCertificateEmail, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RetrieveSiteSeal verify domain ownership for this certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+// siteSealRequest is site seal request.
+func (client AppServiceCertificateOrdersClient) RetrieveSiteSeal(resourceGroupName string, certificateOrderName string, siteSealRequest SiteSealRequest) (result SiteSeal, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "RetrieveSiteSeal")
+ }
+
+ req, err := client.RetrieveSiteSealPreparer(resourceGroupName, certificateOrderName, siteSealRequest)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveSiteSeal", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RetrieveSiteSealSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveSiteSeal", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RetrieveSiteSealResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "RetrieveSiteSeal", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RetrieveSiteSealPreparer prepares the RetrieveSiteSeal request.
+func (client AppServiceCertificateOrdersClient) RetrieveSiteSealPreparer(resourceGroupName string, certificateOrderName string, siteSealRequest SiteSealRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/retrieveSiteSeal", pathParameters),
+ autorest.WithJSON(siteSealRequest),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RetrieveSiteSealSender sends the RetrieveSiteSeal request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) RetrieveSiteSealSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RetrieveSiteSealResponder handles the response to the RetrieveSiteSeal request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) RetrieveSiteSealResponder(resp *http.Response) (result SiteSeal, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ValidatePurchaseInformation validate information for a certificate order.
+//
+// appServiceCertificateOrder is information for a certificate order.
+func (client AppServiceCertificateOrdersClient) ValidatePurchaseInformation(appServiceCertificateOrder AppServiceCertificateOrder) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: appServiceCertificateOrder,
+ Constraints: []validation.Constraint{{Target: "appServiceCertificateOrder.AppServiceCertificateOrderProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "appServiceCertificateOrder.AppServiceCertificateOrderProperties.ValidityInYears", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "appServiceCertificateOrder.AppServiceCertificateOrderProperties.ValidityInYears", Name: validation.InclusiveMaximum, Rule: 3, Chain: nil},
+ {Target: "appServiceCertificateOrder.AppServiceCertificateOrderProperties.ValidityInYears", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "ValidatePurchaseInformation")
+ }
+
+ req, err := client.ValidatePurchaseInformationPreparer(appServiceCertificateOrder)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ValidatePurchaseInformation", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ValidatePurchaseInformationSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ValidatePurchaseInformation", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ValidatePurchaseInformationResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "ValidatePurchaseInformation", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ValidatePurchaseInformationPreparer prepares the ValidatePurchaseInformation request.
+func (client AppServiceCertificateOrdersClient) ValidatePurchaseInformationPreparer(appServiceCertificateOrder AppServiceCertificateOrder) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.CertificateRegistration/validateCertificateRegistrationInformation", pathParameters),
+ autorest.WithJSON(appServiceCertificateOrder),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ValidatePurchaseInformationSender sends the ValidatePurchaseInformation request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) ValidatePurchaseInformationSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ValidatePurchaseInformationResponder handles the response to the ValidatePurchaseInformation request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) ValidatePurchaseInformationResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// VerifyDomainOwnership verify domain ownership for this certificate order.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. certificateOrderName is name of the certificate order.
+func (client AppServiceCertificateOrdersClient) VerifyDomainOwnership(resourceGroupName string, certificateOrderName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceCertificateOrdersClient", "VerifyDomainOwnership")
+ }
+
+ req, err := client.VerifyDomainOwnershipPreparer(resourceGroupName, certificateOrderName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "VerifyDomainOwnership", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.VerifyDomainOwnershipSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "VerifyDomainOwnership", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.VerifyDomainOwnershipResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceCertificateOrdersClient", "VerifyDomainOwnership", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// VerifyDomainOwnershipPreparer prepares the VerifyDomainOwnership request.
+func (client AppServiceCertificateOrdersClient) VerifyDomainOwnershipPreparer(resourceGroupName string, certificateOrderName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "certificateOrderName": autorest.Encode("path", certificateOrderName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-08-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CertificateRegistration/certificateOrders/{certificateOrderName}/verifyDomainOwnership", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// VerifyDomainOwnershipSender sends the VerifyDomainOwnership request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceCertificateOrdersClient) VerifyDomainOwnershipSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// VerifyDomainOwnershipResponder handles the response to the VerifyDomainOwnership request. The method always
+// closes the http.Response Body.
+func (client AppServiceCertificateOrdersClient) VerifyDomainOwnershipResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceenvironments.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceenvironments.go
new file mode 100755
index 000000000000..54f9f9bcb5fe
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceenvironments.go
@@ -0,0 +1,3461 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// AppServiceEnvironmentsClient is the composite Swagger for WebSite Management
+// Client
+type AppServiceEnvironmentsClient struct {
+ ManagementClient
+}
+
+// NewAppServiceEnvironmentsClient creates an instance of the
+// AppServiceEnvironmentsClient client.
+func NewAppServiceEnvironmentsClient(subscriptionID string) AppServiceEnvironmentsClient {
+ return NewAppServiceEnvironmentsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewAppServiceEnvironmentsClientWithBaseURI creates an instance of the
+// AppServiceEnvironmentsClient client.
+func NewAppServiceEnvironmentsClientWithBaseURI(baseURI string, subscriptionID string) AppServiceEnvironmentsClient {
+ return AppServiceEnvironmentsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or update an App Service Environment. This method may
+// poll for completion. Polling can be canceled by passing the cancel channel
+// argument. The channel will be used to cancel polling and any outstanding
+// HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+// hostingEnvironmentEnvelope is configuration details of the App Service
+// Environment.
+func (client AppServiceEnvironmentsClient) CreateOrUpdate(resourceGroupName string, name string, hostingEnvironmentEnvelope AppServiceEnvironmentResource, cancel <-chan struct{}) (<-chan AppServiceEnvironmentResource, <-chan error) {
+ resultChan := make(chan AppServiceEnvironmentResource, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: hostingEnvironmentEnvelope,
+ Constraints: []validation.Constraint{{Target: "hostingEnvironmentEnvelope.AppServiceEnvironment", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "hostingEnvironmentEnvelope.AppServiceEnvironment.Name", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "hostingEnvironmentEnvelope.AppServiceEnvironment.Location", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "hostingEnvironmentEnvelope.AppServiceEnvironment.VirtualNetwork", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "hostingEnvironmentEnvelope.AppServiceEnvironment.WorkerPools", Name: validation.Null, Rule: true, Chain: nil},
+ }}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdate")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result AppServiceEnvironmentResource
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdatePreparer(resourceGroupName, name, hostingEnvironmentEnvelope, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client AppServiceEnvironmentsClient) CreateOrUpdatePreparer(resourceGroupName string, name string, hostingEnvironmentEnvelope AppServiceEnvironmentResource, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}", pathParameters),
+ autorest.WithJSON(hostingEnvironmentEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateResponder(resp *http.Response) (result AppServiceEnvironmentResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusBadRequest, http.StatusNotFound, http.StatusConflict),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateMultiRolePool create or update a multi-role pool. This method
+// may poll for completion. Polling can be canceled by passing the cancel
+// channel argument. The channel will be used to cancel polling and any
+// outstanding HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. multiRolePoolEnvelope
+// is properties of the multi-role pool.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateMultiRolePool(resourceGroupName string, name string, multiRolePoolEnvelope WorkerPoolResource, cancel <-chan struct{}) (<-chan WorkerPoolResource, <-chan error) {
+ resultChan := make(chan WorkerPoolResource, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateMultiRolePool")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result WorkerPoolResource
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdateMultiRolePoolPreparer(resourceGroupName, name, multiRolePoolEnvelope, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateMultiRolePool", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateMultiRolePoolSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateMultiRolePool", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateMultiRolePoolResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateMultiRolePool", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdateMultiRolePoolPreparer prepares the CreateOrUpdateMultiRolePool request.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateMultiRolePoolPreparer(resourceGroupName string, name string, multiRolePoolEnvelope WorkerPoolResource, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default", pathParameters),
+ autorest.WithJSON(multiRolePoolEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateMultiRolePoolSender sends the CreateOrUpdateMultiRolePool request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateMultiRolePoolSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateMultiRolePoolResponder handles the response to the CreateOrUpdateMultiRolePool request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateMultiRolePoolResponder(resp *http.Response) (result WorkerPoolResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusBadRequest, http.StatusNotFound, http.StatusConflict),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateWorkerPool create or update a worker pool. This method may
+// poll for completion. Polling can be canceled by passing the cancel channel
+// argument. The channel will be used to cancel polling and any outstanding
+// HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of the worker pool. workerPoolEnvelope is properties of the worker pool.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateWorkerPool(resourceGroupName string, name string, workerPoolName string, workerPoolEnvelope WorkerPoolResource, cancel <-chan struct{}) (<-chan WorkerPoolResource, <-chan error) {
+ resultChan := make(chan WorkerPoolResource, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateWorkerPool")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result WorkerPoolResource
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdateWorkerPoolPreparer(resourceGroupName, name, workerPoolName, workerPoolEnvelope, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateWorkerPool", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateWorkerPoolSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateWorkerPool", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateWorkerPoolResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "CreateOrUpdateWorkerPool", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdateWorkerPoolPreparer prepares the CreateOrUpdateWorkerPool request.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateWorkerPoolPreparer(resourceGroupName string, name string, workerPoolName string, workerPoolEnvelope WorkerPoolResource, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}", pathParameters),
+ autorest.WithJSON(workerPoolEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateWorkerPoolSender sends the CreateOrUpdateWorkerPool request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateWorkerPoolSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateWorkerPoolResponder handles the response to the CreateOrUpdateWorkerPool request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) CreateOrUpdateWorkerPoolResponder(resp *http.Response) (result WorkerPoolResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusBadRequest, http.StatusNotFound, http.StatusConflict),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete delete an App Service Environment. This method may poll for
+// completion. Polling can be canceled by passing the cancel channel argument.
+// The channel will be used to cancel polling and any outstanding HTTP
+// requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. forceDelete is specify
+// true to force the deletion even if the App Service Environment
+// contains resources. The default is false.
+func (client AppServiceEnvironmentsClient) Delete(resourceGroupName string, name string, forceDelete *bool, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
+ resultChan := make(chan autorest.Response, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "Delete")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result autorest.Response
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.DeletePreparer(resourceGroupName, name, forceDelete, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Delete", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// DeletePreparer prepares the Delete request.
+func (client AppServiceEnvironmentsClient) DeletePreparer(resourceGroupName string, name string, forceDelete *bool, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if forceDelete != nil {
+ queryParameters["forceDelete"] = autorest.Encode("query", *forceDelete)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent, http.StatusBadRequest, http.StatusNotFound, http.StatusConflict),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get get the properties of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) Get(resourceGroupName string, name string) (result AppServiceEnvironmentResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "Get")
+ }
+
+ req, err := client.GetPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client AppServiceEnvironmentsClient) GetPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) GetResponder(resp *http.Response) (result AppServiceEnvironmentResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetDiagnosticsItem get a diagnostics item for an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. diagnosticsName is
+// name of the diagnostics item.
+func (client AppServiceEnvironmentsClient) GetDiagnosticsItem(resourceGroupName string, name string, diagnosticsName string) (result HostingEnvironmentDiagnostics, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "GetDiagnosticsItem")
+ }
+
+ req, err := client.GetDiagnosticsItemPreparer(resourceGroupName, name, diagnosticsName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetDiagnosticsItem", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetDiagnosticsItemSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetDiagnosticsItem", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetDiagnosticsItemResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetDiagnosticsItem", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetDiagnosticsItemPreparer prepares the GetDiagnosticsItem request.
+func (client AppServiceEnvironmentsClient) GetDiagnosticsItemPreparer(resourceGroupName string, name string, diagnosticsName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "diagnosticsName": autorest.Encode("path", diagnosticsName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/diagnostics/{diagnosticsName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetDiagnosticsItemSender sends the GetDiagnosticsItem request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) GetDiagnosticsItemSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetDiagnosticsItemResponder handles the response to the GetDiagnosticsItem request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) GetDiagnosticsItemResponder(resp *http.Response) (result HostingEnvironmentDiagnostics, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetMultiRolePool get properties of a multi-role pool.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) GetMultiRolePool(resourceGroupName string, name string) (result WorkerPoolResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "GetMultiRolePool")
+ }
+
+ req, err := client.GetMultiRolePoolPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetMultiRolePool", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetMultiRolePoolSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetMultiRolePool", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetMultiRolePoolResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetMultiRolePool", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetMultiRolePoolPreparer prepares the GetMultiRolePool request.
+func (client AppServiceEnvironmentsClient) GetMultiRolePoolPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetMultiRolePoolSender sends the GetMultiRolePool request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) GetMultiRolePoolSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetMultiRolePoolResponder handles the response to the GetMultiRolePool request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) GetMultiRolePoolResponder(resp *http.Response) (result WorkerPoolResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetWorkerPool get properties of a worker pool.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of the worker pool.
+func (client AppServiceEnvironmentsClient) GetWorkerPool(resourceGroupName string, name string, workerPoolName string) (result WorkerPoolResource, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "GetWorkerPool")
+ }
+
+ req, err := client.GetWorkerPoolPreparer(resourceGroupName, name, workerPoolName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetWorkerPool", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetWorkerPoolSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetWorkerPool", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetWorkerPoolResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "GetWorkerPool", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetWorkerPoolPreparer prepares the GetWorkerPool request.
+func (client AppServiceEnvironmentsClient) GetWorkerPoolPreparer(resourceGroupName string, name string, workerPoolName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetWorkerPoolSender sends the GetWorkerPool request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) GetWorkerPoolSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetWorkerPoolResponder handles the response to the GetWorkerPool request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) GetWorkerPoolResponder(resp *http.Response) (result WorkerPoolResource, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List get all App Service Environments for a subscription.
+func (client AppServiceEnvironmentsClient) List() (result AppServiceEnvironmentCollection, err error) {
+ req, err := client.ListPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client AppServiceEnvironmentsClient) ListPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/hostingEnvironments", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListResponder(resp *http.Response) (result AppServiceEnvironmentCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 AppServiceEnvironmentsClient) ListNextResults(lastResults AppServiceEnvironmentCollection) (result AppServiceEnvironmentCollection, err error) {
+ req, err := lastResults.AppServiceEnvironmentCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "List", 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, "web.AppServiceEnvironmentsClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListAppServicePlans get all App Service plans in an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListAppServicePlans(resourceGroupName string, name string) (result AppServicePlanCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListAppServicePlans")
+ }
+
+ req, err := client.ListAppServicePlansPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListAppServicePlans", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAppServicePlansSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListAppServicePlans", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAppServicePlansResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListAppServicePlans", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListAppServicePlansPreparer prepares the ListAppServicePlans request.
+func (client AppServiceEnvironmentsClient) ListAppServicePlansPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/serverfarms", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListAppServicePlansSender sends the ListAppServicePlans request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListAppServicePlansSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListAppServicePlansResponder handles the response to the ListAppServicePlans request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListAppServicePlansResponder(resp *http.Response) (result AppServicePlanCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAppServicePlansNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListAppServicePlansNextResults(lastResults AppServicePlanCollection) (result AppServicePlanCollection, err error) {
+ req, err := lastResults.AppServicePlanCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListAppServicePlans", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListAppServicePlansSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListAppServicePlans", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListAppServicePlansResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListAppServicePlans", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListByResourceGroup get all App Service Environments in a resource group.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs.
+func (client AppServiceEnvironmentsClient) ListByResourceGroup(resourceGroupName string) (result AppServiceEnvironmentCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListByResourceGroup")
+ }
+
+ req, err := client.ListByResourceGroupPreparer(resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client AppServiceEnvironmentsClient) ListByResourceGroupPreparer(resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListByResourceGroupResponder(resp *http.Response) (result AppServiceEnvironmentCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListByResourceGroupNextResults(lastResults AppServiceEnvironmentCollection) (result AppServiceEnvironmentCollection, err error) {
+ req, err := lastResults.AppServiceEnvironmentCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListByResourceGroup", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListCapacities get the used, available, and total worker capacity an App
+// Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListCapacities(resourceGroupName string, name string) (result StampCapacityCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListCapacities")
+ }
+
+ req, err := client.ListCapacitiesPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListCapacities", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListCapacitiesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListCapacities", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListCapacitiesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListCapacities", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListCapacitiesPreparer prepares the ListCapacities request.
+func (client AppServiceEnvironmentsClient) ListCapacitiesPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/capacities/compute", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListCapacitiesSender sends the ListCapacities request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListCapacitiesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListCapacitiesResponder handles the response to the ListCapacities request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListCapacitiesResponder(resp *http.Response) (result StampCapacityCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListCapacitiesNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListCapacitiesNextResults(lastResults StampCapacityCollection) (result StampCapacityCollection, err error) {
+ req, err := lastResults.StampCapacityCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListCapacities", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListCapacitiesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListCapacities", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListCapacitiesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListCapacities", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListDiagnostics get diagnostic information for an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListDiagnostics(resourceGroupName string, name string) (result ListHostingEnvironmentDiagnostics, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListDiagnostics")
+ }
+
+ req, err := client.ListDiagnosticsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListDiagnostics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListDiagnosticsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListDiagnostics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListDiagnosticsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListDiagnostics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListDiagnosticsPreparer prepares the ListDiagnostics request.
+func (client AppServiceEnvironmentsClient) ListDiagnosticsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/diagnostics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListDiagnosticsSender sends the ListDiagnostics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListDiagnosticsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListDiagnosticsResponder handles the response to the ListDiagnostics request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListDiagnosticsResponder(resp *http.Response) (result ListHostingEnvironmentDiagnostics, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricDefinitions get global metric definitions of an App Service
+// Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListMetricDefinitions(resourceGroupName string, name string) (result MetricDefinition, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMetricDefinitions")
+ }
+
+ req, err := client.ListMetricDefinitionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetricDefinitions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetricDefinitions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetricDefinitions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricDefinitionsPreparer prepares the ListMetricDefinitions request.
+func (client AppServiceEnvironmentsClient) ListMetricDefinitionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricDefinitionsSender sends the ListMetricDefinitions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricDefinitionsResponder handles the response to the ListMetricDefinitions request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMetricDefinitionsResponder(resp *http.Response) (result MetricDefinition, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetrics get global metrics of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. details is specify
+// true to include instance details. The default is
+// false. filter is return only usages/metrics specified in the
+// filter. Filter conforms to odata syntax. Example: $filter=(name.value eq
+// 'Metric1' or name.value eq 'Metric2') and startTime eq
+// '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain
+// eq duration'[Hour|Minute|Day]'.
+func (client AppServiceEnvironmentsClient) ListMetrics(resourceGroupName string, name string, details *bool, filter string) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMetrics")
+ }
+
+ req, err := client.ListMetricsPreparer(resourceGroupName, name, details, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetrics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetrics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetrics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricsPreparer prepares the ListMetrics request.
+func (client AppServiceEnvironmentsClient) ListMetricsPreparer(resourceGroupName string, name string, details *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricsSender sends the ListMetrics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMetricsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricsResponder handles the response to the ListMetrics request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMetricsResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMetricsNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetrics", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetrics", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMetrics", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMultiRoleMetricDefinitions get metric definitions for a multi-role pool
+// of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitions(resourceGroupName string, name string) (result ResourceMetricDefinitionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetricDefinitions")
+ }
+
+ req, err := client.ListMultiRoleMetricDefinitionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetricDefinitions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMultiRoleMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetricDefinitions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMultiRoleMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetricDefinitions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMultiRoleMetricDefinitionsPreparer prepares the ListMultiRoleMetricDefinitions request.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMultiRoleMetricDefinitionsSender sends the ListMultiRoleMetricDefinitions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMultiRoleMetricDefinitionsResponder handles the response to the ListMultiRoleMetricDefinitions request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitionsResponder(resp *http.Response) (result ResourceMetricDefinitionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMultiRoleMetricDefinitionsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricDefinitionsNextResults(lastResults ResourceMetricDefinitionCollection) (result ResourceMetricDefinitionCollection, err error) {
+ req, err := lastResults.ResourceMetricDefinitionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetricDefinitions", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMultiRoleMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetricDefinitions", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMultiRoleMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetricDefinitions", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMultiRoleMetrics get metrics for a multi-role pool of an App Service
+// Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. startTime is beginning
+// time of the metrics query. endTime is end time of the metrics query.
+// timeGrain is time granularity of the metrics query. details is specify
+// true to include instance details. The default is
+// false. filter is return only usages/metrics specified in the
+// filter. Filter conforms to odata syntax. Example: $filter=(name.value eq
+// 'Metric1' or name.value eq 'Metric2') and startTime eq
+// '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain
+// eq duration'[Hour|Minute|Day]'.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetrics(resourceGroupName string, name string, startTime string, endTime string, timeGrain string, details *bool, filter string) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetrics")
+ }
+
+ req, err := client.ListMultiRoleMetricsPreparer(resourceGroupName, name, startTime, endTime, timeGrain, details, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetrics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMultiRoleMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetrics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMultiRoleMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetrics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMultiRoleMetricsPreparer prepares the ListMultiRoleMetrics request.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricsPreparer(resourceGroupName string, name string, startTime string, endTime string, timeGrain string, details *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(startTime) > 0 {
+ queryParameters["startTime"] = autorest.Encode("query", startTime)
+ }
+ if len(endTime) > 0 {
+ queryParameters["endTime"] = autorest.Encode("query", endTime)
+ }
+ if len(timeGrain) > 0 {
+ queryParameters["timeGrain"] = autorest.Encode("query", timeGrain)
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMultiRoleMetricsSender sends the ListMultiRoleMetrics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMultiRoleMetricsResponder handles the response to the ListMultiRoleMetrics request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricsResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMultiRoleMetricsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMultiRoleMetricsNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetrics", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMultiRoleMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetrics", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMultiRoleMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleMetrics", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMultiRolePoolInstanceMetricDefinitions get metric definitions for a
+// specific instance of a multi-role pool of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. instance is name of
+// the instance in the multi-role pool.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefinitions(resourceGroupName string, name string, instance string) (result ResourceMetricDefinitionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetricDefinitions")
+ }
+
+ req, err := client.ListMultiRolePoolInstanceMetricDefinitionsPreparer(resourceGroupName, name, instance)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetricDefinitions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolInstanceMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetricDefinitions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMultiRolePoolInstanceMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetricDefinitions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMultiRolePoolInstanceMetricDefinitionsPreparer prepares the ListMultiRolePoolInstanceMetricDefinitions request.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefinitionsPreparer(resourceGroupName string, name string, instance string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instance": autorest.Encode("path", instance),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/instances/{instance}/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMultiRolePoolInstanceMetricDefinitionsSender sends the ListMultiRolePoolInstanceMetricDefinitions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMultiRolePoolInstanceMetricDefinitionsResponder handles the response to the ListMultiRolePoolInstanceMetricDefinitions request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefinitionsResponder(resp *http.Response) (result ResourceMetricDefinitionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMultiRolePoolInstanceMetricDefinitionsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricDefinitionsNextResults(lastResults ResourceMetricDefinitionCollection) (result ResourceMetricDefinitionCollection, err error) {
+ req, err := lastResults.ResourceMetricDefinitionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetricDefinitions", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolInstanceMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetricDefinitions", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMultiRolePoolInstanceMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetricDefinitions", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMultiRolePoolInstanceMetrics get metrics for a specific instance of a
+// multi-role pool of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. instance is name of
+// the instance in the multi-role pool. details is specify true to
+// include instance details. The default is false.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetrics(resourceGroupName string, name string, instance string, details *bool) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetrics")
+ }
+
+ req, err := client.ListMultiRolePoolInstanceMetricsPreparer(resourceGroupName, name, instance, details)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetrics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolInstanceMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetrics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMultiRolePoolInstanceMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetrics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMultiRolePoolInstanceMetricsPreparer prepares the ListMultiRolePoolInstanceMetrics request.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricsPreparer(resourceGroupName string, name string, instance string, details *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instance": autorest.Encode("path", instance),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/instances/{instance}metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMultiRolePoolInstanceMetricsSender sends the ListMultiRolePoolInstanceMetrics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMultiRolePoolInstanceMetricsResponder handles the response to the ListMultiRolePoolInstanceMetrics request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricsResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMultiRolePoolInstanceMetricsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolInstanceMetricsNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetrics", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolInstanceMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetrics", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMultiRolePoolInstanceMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolInstanceMetrics", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMultiRolePools get all multi-role pools.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListMultiRolePools(resourceGroupName string, name string) (result WorkerPoolCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePools")
+ }
+
+ req, err := client.ListMultiRolePoolsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePools", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePools", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMultiRolePoolsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePools", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMultiRolePoolsPreparer prepares the ListMultiRolePools request.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMultiRolePoolsSender sends the ListMultiRolePools request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMultiRolePoolsResponder handles the response to the ListMultiRolePools request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolsResponder(resp *http.Response) (result WorkerPoolCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMultiRolePoolsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolsNextResults(lastResults WorkerPoolCollection) (result WorkerPoolCollection, err error) {
+ req, err := lastResults.WorkerPoolCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePools", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePools", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMultiRolePoolsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePools", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMultiRolePoolSkus get available SKUs for scaling a multi-role pool.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolSkus(resourceGroupName string, name string) (result SkuInfoCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolSkus")
+ }
+
+ req, err := client.ListMultiRolePoolSkusPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolSkus", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolSkusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolSkus", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMultiRolePoolSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolSkus", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMultiRolePoolSkusPreparer prepares the ListMultiRolePoolSkus request.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolSkusPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/skus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMultiRolePoolSkusSender sends the ListMultiRolePoolSkus request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolSkusSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMultiRolePoolSkusResponder handles the response to the ListMultiRolePoolSkus request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolSkusResponder(resp *http.Response) (result SkuInfoCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMultiRolePoolSkusNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMultiRolePoolSkusNextResults(lastResults SkuInfoCollection) (result SkuInfoCollection, err error) {
+ req, err := lastResults.SkuInfoCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolSkus", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMultiRolePoolSkusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolSkus", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMultiRolePoolSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRolePoolSkus", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMultiRoleUsages get usage metrics for a multi-role pool of an App
+// Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListMultiRoleUsages(resourceGroupName string, name string) (result UsageCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleUsages")
+ }
+
+ req, err := client.ListMultiRoleUsagesPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleUsages", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMultiRoleUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleUsages", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMultiRoleUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleUsages", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMultiRoleUsagesPreparer prepares the ListMultiRoleUsages request.
+func (client AppServiceEnvironmentsClient) ListMultiRoleUsagesPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMultiRoleUsagesSender sends the ListMultiRoleUsages request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListMultiRoleUsagesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMultiRoleUsagesResponder handles the response to the ListMultiRoleUsages request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListMultiRoleUsagesResponder(resp *http.Response) (result UsageCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMultiRoleUsagesNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListMultiRoleUsagesNextResults(lastResults UsageCollection) (result UsageCollection, err error) {
+ req, err := lastResults.UsageCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleUsages", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMultiRoleUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleUsages", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMultiRoleUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListMultiRoleUsages", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListOperations list all currently running operations on the App Service
+// Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListOperations(resourceGroupName string, name string) (result ListOperation, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListOperations")
+ }
+
+ req, err := client.ListOperationsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListOperations", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListOperationsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListOperations", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListOperationsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListOperations", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListOperationsPreparer prepares the ListOperations request.
+func (client AppServiceEnvironmentsClient) ListOperationsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/operations", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListOperationsSender sends the ListOperations request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListOperationsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListOperationsResponder handles the response to the ListOperations request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListOperationsResponder(resp *http.Response) (result ListOperation, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListUsages get global usage metrics of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. filter is return only
+// usages/metrics specified in the filter. Filter conforms to odata syntax.
+// Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and
+// startTime eq '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z'
+// and timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppServiceEnvironmentsClient) ListUsages(resourceGroupName string, name string, filter string) (result CsmUsageQuotaCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListUsages")
+ }
+
+ req, err := client.ListUsagesPreparer(resourceGroupName, name, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListUsages", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListUsages", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListUsages", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListUsagesPreparer prepares the ListUsages request.
+func (client AppServiceEnvironmentsClient) ListUsagesPreparer(resourceGroupName string, name string, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListUsagesSender sends the ListUsages request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListUsagesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListUsagesResponder handles the response to the ListUsages request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListUsagesResponder(resp *http.Response) (result CsmUsageQuotaCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListUsagesNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListUsagesNextResults(lastResults CsmUsageQuotaCollection) (result CsmUsageQuotaCollection, err error) {
+ req, err := lastResults.CsmUsageQuotaCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListUsages", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListUsages", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListUsages", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListVips get IP addresses assigned to an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListVips(resourceGroupName string, name string) (result AddressResponse, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListVips")
+ }
+
+ req, err := client.ListVipsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListVips", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVipsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListVips", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListVipsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListVips", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListVipsPreparer prepares the ListVips request.
+func (client AppServiceEnvironmentsClient) ListVipsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/capacities/virtualip", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListVipsSender sends the ListVips request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListVipsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListVipsResponder handles the response to the ListVips request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListVipsResponder(resp *http.Response) (result AddressResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebApps get all apps in an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. propertiesToInclude is
+// comma separated list of app properties to include.
+func (client AppServiceEnvironmentsClient) ListWebApps(resourceGroupName string, name string, propertiesToInclude string) (result AppCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWebApps")
+ }
+
+ req, err := client.ListWebAppsPreparer(resourceGroupName, name, propertiesToInclude)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebApps", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWebAppsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebApps", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWebAppsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebApps", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWebAppsPreparer prepares the ListWebApps request.
+func (client AppServiceEnvironmentsClient) ListWebAppsPreparer(resourceGroupName string, name string, propertiesToInclude string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(propertiesToInclude) > 0 {
+ queryParameters["propertiesToInclude"] = autorest.Encode("query", propertiesToInclude)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/sites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWebAppsSender sends the ListWebApps request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWebAppsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWebAppsResponder handles the response to the ListWebApps request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWebAppsResponder(resp *http.Response) (result AppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebAppsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWebAppsNextResults(lastResults AppCollection) (result AppCollection, err error) {
+ req, err := lastResults.AppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebApps", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWebAppsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebApps", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWebAppsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebApps", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWebWorkerMetricDefinitions get metric definitions for a worker pool of
+// an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of the worker pool.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitions(resourceGroupName string, name string, workerPoolName string) (result ResourceMetricDefinitionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetricDefinitions")
+ }
+
+ req, err := client.ListWebWorkerMetricDefinitionsPreparer(resourceGroupName, name, workerPoolName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetricDefinitions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWebWorkerMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetricDefinitions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWebWorkerMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetricDefinitions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWebWorkerMetricDefinitionsPreparer prepares the ListWebWorkerMetricDefinitions request.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitionsPreparer(resourceGroupName string, name string, workerPoolName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWebWorkerMetricDefinitionsSender sends the ListWebWorkerMetricDefinitions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWebWorkerMetricDefinitionsResponder handles the response to the ListWebWorkerMetricDefinitions request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitionsResponder(resp *http.Response) (result ResourceMetricDefinitionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebWorkerMetricDefinitionsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricDefinitionsNextResults(lastResults ResourceMetricDefinitionCollection) (result ResourceMetricDefinitionCollection, err error) {
+ req, err := lastResults.ResourceMetricDefinitionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetricDefinitions", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWebWorkerMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetricDefinitions", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWebWorkerMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetricDefinitions", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWebWorkerMetrics get metrics for a worker pool of a
+// AppServiceEnvironment (App Service Environment).
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of worker pool details is specify true to include instance
+// details. The default is false. filter is return only
+// usages/metrics specified in the filter. Filter conforms to odata syntax.
+// Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and
+// startTime eq '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z'
+// and timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetrics(resourceGroupName string, name string, workerPoolName string, details *bool, filter string) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetrics")
+ }
+
+ req, err := client.ListWebWorkerMetricsPreparer(resourceGroupName, name, workerPoolName, details, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetrics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWebWorkerMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetrics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWebWorkerMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetrics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWebWorkerMetricsPreparer prepares the ListWebWorkerMetrics request.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricsPreparer(resourceGroupName string, name string, workerPoolName string, details *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWebWorkerMetricsSender sends the ListWebWorkerMetrics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWebWorkerMetricsResponder handles the response to the ListWebWorkerMetrics request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricsResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebWorkerMetricsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWebWorkerMetricsNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetrics", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWebWorkerMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetrics", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWebWorkerMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerMetrics", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWebWorkerUsages get usage metrics for a worker pool of an App Service
+// Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of the worker pool.
+func (client AppServiceEnvironmentsClient) ListWebWorkerUsages(resourceGroupName string, name string, workerPoolName string) (result UsageCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerUsages")
+ }
+
+ req, err := client.ListWebWorkerUsagesPreparer(resourceGroupName, name, workerPoolName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerUsages", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWebWorkerUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerUsages", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWebWorkerUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerUsages", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWebWorkerUsagesPreparer prepares the ListWebWorkerUsages request.
+func (client AppServiceEnvironmentsClient) ListWebWorkerUsagesPreparer(resourceGroupName string, name string, workerPoolName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/usages", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWebWorkerUsagesSender sends the ListWebWorkerUsages request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWebWorkerUsagesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWebWorkerUsagesResponder handles the response to the ListWebWorkerUsages request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWebWorkerUsagesResponder(resp *http.Response) (result UsageCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebWorkerUsagesNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWebWorkerUsagesNextResults(lastResults UsageCollection) (result UsageCollection, err error) {
+ req, err := lastResults.UsageCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerUsages", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWebWorkerUsagesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerUsages", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWebWorkerUsagesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWebWorkerUsages", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWorkerPoolInstanceMetricDefinitions get metric definitions for a
+// specific instance of a worker pool of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of the worker pool. instance is name of the instance in the worker pool.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitions(resourceGroupName string, name string, workerPoolName string, instance string) (result ResourceMetricDefinitionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetricDefinitions")
+ }
+
+ req, err := client.ListWorkerPoolInstanceMetricDefinitionsPreparer(resourceGroupName, name, workerPoolName, instance)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetricDefinitions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWorkerPoolInstanceMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetricDefinitions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWorkerPoolInstanceMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetricDefinitions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWorkerPoolInstanceMetricDefinitionsPreparer prepares the ListWorkerPoolInstanceMetricDefinitions request.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitionsPreparer(resourceGroupName string, name string, workerPoolName string, instance string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instance": autorest.Encode("path", instance),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/instances/{instance}/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWorkerPoolInstanceMetricDefinitionsSender sends the ListWorkerPoolInstanceMetricDefinitions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWorkerPoolInstanceMetricDefinitionsResponder handles the response to the ListWorkerPoolInstanceMetricDefinitions request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitionsResponder(resp *http.Response) (result ResourceMetricDefinitionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWorkerPoolInstanceMetricDefinitionsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricDefinitionsNextResults(lastResults ResourceMetricDefinitionCollection) (result ResourceMetricDefinitionCollection, err error) {
+ req, err := lastResults.ResourceMetricDefinitionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetricDefinitions", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWorkerPoolInstanceMetricDefinitionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetricDefinitions", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWorkerPoolInstanceMetricDefinitionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetricDefinitions", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWorkerPoolInstanceMetrics get metrics for a specific instance of a
+// worker pool of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of the worker pool. instance is name of the instance in the worker pool.
+// details is specify true to include instance details. The
+// default is false. filter is return only usages/metrics
+// specified in the filter. Filter conforms to odata syntax. Example:
+// $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime
+// eq '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and
+// timeGrain eq duration'[Hour|Minute|Day]'.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetrics(resourceGroupName string, name string, workerPoolName string, instance string, details *bool, filter string) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetrics")
+ }
+
+ req, err := client.ListWorkerPoolInstanceMetricsPreparer(resourceGroupName, name, workerPoolName, instance, details, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetrics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWorkerPoolInstanceMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetrics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWorkerPoolInstanceMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetrics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWorkerPoolInstanceMetricsPreparer prepares the ListWorkerPoolInstanceMetrics request.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricsPreparer(resourceGroupName string, name string, workerPoolName string, instance string, details *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "instance": autorest.Encode("path", instance),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/instances/{instance}metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWorkerPoolInstanceMetricsSender sends the ListWorkerPoolInstanceMetrics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWorkerPoolInstanceMetricsResponder handles the response to the ListWorkerPoolInstanceMetrics request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricsResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWorkerPoolInstanceMetricsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolInstanceMetricsNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetrics", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWorkerPoolInstanceMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetrics", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWorkerPoolInstanceMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolInstanceMetrics", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWorkerPools get all worker pools of an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) ListWorkerPools(resourceGroupName string, name string) (result WorkerPoolCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPools")
+ }
+
+ req, err := client.ListWorkerPoolsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPools", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWorkerPoolsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPools", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWorkerPoolsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPools", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWorkerPoolsPreparer prepares the ListWorkerPools request.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWorkerPoolsSender sends the ListWorkerPools request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWorkerPoolsResponder handles the response to the ListWorkerPools request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolsResponder(resp *http.Response) (result WorkerPoolCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWorkerPoolsNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolsNextResults(lastResults WorkerPoolCollection) (result WorkerPoolCollection, err error) {
+ req, err := lastResults.WorkerPoolCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPools", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWorkerPoolsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPools", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWorkerPoolsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPools", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWorkerPoolSkus get available SKUs for scaling a worker pool.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment. workerPoolName is name
+// of the worker pool.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolSkus(resourceGroupName string, name string, workerPoolName string) (result SkuInfoCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolSkus")
+ }
+
+ req, err := client.ListWorkerPoolSkusPreparer(resourceGroupName, name, workerPoolName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolSkus", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWorkerPoolSkusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolSkus", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWorkerPoolSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolSkus", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWorkerPoolSkusPreparer prepares the ListWorkerPoolSkus request.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolSkusPreparer(resourceGroupName string, name string, workerPoolName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerPoolName": autorest.Encode("path", workerPoolName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/skus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWorkerPoolSkusSender sends the ListWorkerPoolSkus request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolSkusSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWorkerPoolSkusResponder handles the response to the ListWorkerPoolSkus request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolSkusResponder(resp *http.Response) (result SkuInfoCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWorkerPoolSkusNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ListWorkerPoolSkusNextResults(lastResults SkuInfoCollection) (result SkuInfoCollection, err error) {
+ req, err := lastResults.SkuInfoCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolSkus", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWorkerPoolSkusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolSkus", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWorkerPoolSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "ListWorkerPoolSkus", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// Reboot reboot all machines in an App Service Environment.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) Reboot(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "Reboot")
+ }
+
+ req, err := client.RebootPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Reboot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RebootSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Reboot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RebootResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Reboot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RebootPreparer prepares the Reboot request.
+func (client AppServiceEnvironmentsClient) RebootPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/reboot", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RebootSender sends the Reboot request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) RebootSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RebootResponder handles the response to the Reboot request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) RebootResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusBadRequest, http.StatusNotFound, http.StatusConflict),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Resume resume an App Service Environment. This method may poll for
+// completion. Polling can be canceled by passing the cancel channel argument.
+// The channel will be used to cancel polling and any outstanding HTTP
+// requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) Resume(resourceGroupName string, name string, cancel <-chan struct{}) (result AppCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "Resume")
+ }
+
+ req, err := client.ResumePreparer(resourceGroupName, name, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Resume", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ResumeSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Resume", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ResumeResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Resume", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ResumePreparer prepares the Resume request.
+func (client AppServiceEnvironmentsClient) ResumePreparer(resourceGroupName string, name string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/resume", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// ResumeSender sends the Resume request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) ResumeSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// ResumeResponder handles the response to the Resume request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) ResumeResponder(resp *http.Response) (result AppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ResumeNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) ResumeNextResults(lastResults AppCollection) (result AppCollection, err error) {
+ req, err := lastResults.AppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Resume", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ResumeSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Resume", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ResumeResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Resume", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// Suspend suspend an App Service Environment. This method may poll for
+// completion. Polling can be canceled by passing the cancel channel argument.
+// The channel will be used to cancel polling and any outstanding HTTP
+// requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service Environment.
+func (client AppServiceEnvironmentsClient) Suspend(resourceGroupName string, name string, cancel <-chan struct{}) (result AppCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServiceEnvironmentsClient", "Suspend")
+ }
+
+ req, err := client.SuspendPreparer(resourceGroupName, name, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Suspend", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.SuspendSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Suspend", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.SuspendResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Suspend", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// SuspendPreparer prepares the Suspend request.
+func (client AppServiceEnvironmentsClient) SuspendPreparer(resourceGroupName string, name string, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/suspend", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// SuspendSender sends the Suspend request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServiceEnvironmentsClient) SuspendSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// SuspendResponder handles the response to the Suspend request. The method always
+// closes the http.Response Body.
+func (client AppServiceEnvironmentsClient) SuspendResponder(resp *http.Response) (result AppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// SuspendNextResults retrieves the next set of results, if any.
+func (client AppServiceEnvironmentsClient) SuspendNextResults(lastResults AppCollection) (result AppCollection, err error) {
+ req, err := lastResults.AppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Suspend", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.SuspendSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Suspend", resp, "Failure sending next results request")
+ }
+
+ result, err = client.SuspendResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServiceEnvironmentsClient", "Suspend", resp, "Failure responding to next results request")
+ }
+
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceplans.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceplans.go
new file mode 100755
index 000000000000..d4e36287579b
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/appserviceplans.go
@@ -0,0 +1,2237 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// AppServicePlansClient is the composite Swagger for WebSite Management Client
+type AppServicePlansClient struct {
+ ManagementClient
+}
+
+// NewAppServicePlansClient creates an instance of the AppServicePlansClient
+// client.
+func NewAppServicePlansClient(subscriptionID string) AppServicePlansClient {
+ return NewAppServicePlansClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewAppServicePlansClientWithBaseURI creates an instance of the
+// AppServicePlansClient client.
+func NewAppServicePlansClientWithBaseURI(baseURI string, subscriptionID string) AppServicePlansClient {
+ return AppServicePlansClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates an App Service Plan. This method may poll
+// for completion. Polling can be canceled by passing the cancel channel
+// argument. The channel will be used to cancel polling and any outstanding
+// HTTP requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. appServicePlan is details of
+// the App Service plan.
+func (client AppServicePlansClient) CreateOrUpdate(resourceGroupName string, name string, appServicePlan AppServicePlan, cancel <-chan struct{}) (<-chan AppServicePlan, <-chan error) {
+ resultChan := make(chan AppServicePlan, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "CreateOrUpdate")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result AppServicePlan
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdatePreparer(resourceGroupName, name, appServicePlan, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client AppServicePlansClient) CreateOrUpdatePreparer(resourceGroupName string, name string, appServicePlan AppServicePlan, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}", pathParameters),
+ autorest.WithJSON(appServicePlan),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) CreateOrUpdateResponder(resp *http.Response) (result AppServicePlan, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateVnetRoute create or update a Virtual Network route in an App
+// Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network. routeName is name of the Virtual Network route. route is
+// definition of the Virtual Network route.
+func (client AppServicePlansClient) CreateOrUpdateVnetRoute(resourceGroupName string, name string, vnetName string, routeName string, route VnetRoute) (result VnetRoute, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "CreateOrUpdateVnetRoute")
+ }
+
+ req, err := client.CreateOrUpdateVnetRoutePreparer(resourceGroupName, name, vnetName, routeName, route)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "CreateOrUpdateVnetRoute", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateVnetRouteSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "CreateOrUpdateVnetRoute", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateVnetRouteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "CreateOrUpdateVnetRoute", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateVnetRoutePreparer prepares the CreateOrUpdateVnetRoute request.
+func (client AppServicePlansClient) CreateOrUpdateVnetRoutePreparer(resourceGroupName string, name string, vnetName string, routeName string, route VnetRoute) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeName": autorest.Encode("path", routeName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}/routes/{routeName}", pathParameters),
+ autorest.WithJSON(route),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateVnetRouteSender sends the CreateOrUpdateVnetRoute request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) CreateOrUpdateVnetRouteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateVnetRouteResponder handles the response to the CreateOrUpdateVnetRoute request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) CreateOrUpdateVnetRouteResponder(resp *http.Response) (result VnetRoute, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusBadRequest, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete delete an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan.
+func (client AppServicePlansClient) Delete(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "Delete")
+ }
+
+ req, err := client.DeletePreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "Delete", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client AppServicePlansClient) DeletePreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteHybridConnection delete a Hybrid Connection in use in an App Service
+// plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. namespaceName is name of the
+// Service Bus namespace. relayName is name of the Service Bus relay.
+func (client AppServicePlansClient) DeleteHybridConnection(resourceGroupName string, name string, namespaceName string, relayName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "DeleteHybridConnection")
+ }
+
+ req, err := client.DeleteHybridConnectionPreparer(resourceGroupName, name, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "DeleteHybridConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteHybridConnectionSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "DeleteHybridConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "DeleteHybridConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteHybridConnectionPreparer prepares the DeleteHybridConnection request.
+func (client AppServicePlansClient) DeleteHybridConnectionPreparer(resourceGroupName string, name string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteHybridConnectionSender sends the DeleteHybridConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) DeleteHybridConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteHybridConnectionResponder handles the response to the DeleteHybridConnection request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) DeleteHybridConnectionResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteVnetRoute delete a Virtual Network route in an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network. routeName is name of the Virtual Network route.
+func (client AppServicePlansClient) DeleteVnetRoute(resourceGroupName string, name string, vnetName string, routeName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "DeleteVnetRoute")
+ }
+
+ req, err := client.DeleteVnetRoutePreparer(resourceGroupName, name, vnetName, routeName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "DeleteVnetRoute", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteVnetRouteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "DeleteVnetRoute", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteVnetRouteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "DeleteVnetRoute", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteVnetRoutePreparer prepares the DeleteVnetRoute request.
+func (client AppServicePlansClient) DeleteVnetRoutePreparer(resourceGroupName string, name string, vnetName string, routeName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeName": autorest.Encode("path", routeName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}/routes/{routeName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteVnetRouteSender sends the DeleteVnetRoute request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) DeleteVnetRouteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteVnetRouteResponder handles the response to the DeleteVnetRoute request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) DeleteVnetRouteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get get an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan.
+func (client AppServicePlansClient) Get(resourceGroupName string, name string) (result AppServicePlan, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "Get")
+ }
+
+ req, err := client.GetPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client AppServicePlansClient) GetPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) GetResponder(resp *http.Response) (result AppServicePlan, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetHybridConnection retrieve a Hybrid Connection in use in an App Service
+// plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. namespaceName is name of the
+// Service Bus namespace. relayName is name of the Service Bus relay.
+func (client AppServicePlansClient) GetHybridConnection(resourceGroupName string, name string, namespaceName string, relayName string) (result HybridConnection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "GetHybridConnection")
+ }
+
+ req, err := client.GetHybridConnectionPreparer(resourceGroupName, name, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetHybridConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetHybridConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetHybridConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetHybridConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetHybridConnectionPreparer prepares the GetHybridConnection request.
+func (client AppServicePlansClient) GetHybridConnectionPreparer(resourceGroupName string, name string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetHybridConnectionSender sends the GetHybridConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) GetHybridConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetHybridConnectionResponder handles the response to the GetHybridConnection request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) GetHybridConnectionResponder(resp *http.Response) (result HybridConnection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetHybridConnectionPlanLimit get the maximum number of Hybrid Connections
+// allowed in an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan.
+func (client AppServicePlansClient) GetHybridConnectionPlanLimit(resourceGroupName string, name string) (result HybridConnectionLimits, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "GetHybridConnectionPlanLimit")
+ }
+
+ req, err := client.GetHybridConnectionPlanLimitPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetHybridConnectionPlanLimit", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetHybridConnectionPlanLimitSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetHybridConnectionPlanLimit", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetHybridConnectionPlanLimitResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetHybridConnectionPlanLimit", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetHybridConnectionPlanLimitPreparer prepares the GetHybridConnectionPlanLimit request.
+func (client AppServicePlansClient) GetHybridConnectionPlanLimitPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/hybridConnectionPlanLimits/limit", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetHybridConnectionPlanLimitSender sends the GetHybridConnectionPlanLimit request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) GetHybridConnectionPlanLimitSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetHybridConnectionPlanLimitResponder handles the response to the GetHybridConnectionPlanLimit request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) GetHybridConnectionPlanLimitResponder(resp *http.Response) (result HybridConnectionLimits, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetRouteForVnet get a Virtual Network route in an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network. routeName is name of the Virtual Network route.
+func (client AppServicePlansClient) GetRouteForVnet(resourceGroupName string, name string, vnetName string, routeName string) (result ListVnetRoute, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "GetRouteForVnet")
+ }
+
+ req, err := client.GetRouteForVnetPreparer(resourceGroupName, name, vnetName, routeName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetRouteForVnet", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetRouteForVnetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetRouteForVnet", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetRouteForVnetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetRouteForVnet", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetRouteForVnetPreparer prepares the GetRouteForVnet request.
+func (client AppServicePlansClient) GetRouteForVnetPreparer(resourceGroupName string, name string, vnetName string, routeName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeName": autorest.Encode("path", routeName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}/routes/{routeName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetRouteForVnetSender sends the GetRouteForVnet request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) GetRouteForVnetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetRouteForVnetResponder handles the response to the GetRouteForVnet request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) GetRouteForVnetResponder(resp *http.Response) (result ListVnetRoute, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVnetFromServerFarm get a Virtual Network associated with an App Service
+// plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network.
+func (client AppServicePlansClient) GetVnetFromServerFarm(resourceGroupName string, name string, vnetName string) (result VnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "GetVnetFromServerFarm")
+ }
+
+ req, err := client.GetVnetFromServerFarmPreparer(resourceGroupName, name, vnetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetVnetFromServerFarm", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVnetFromServerFarmSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetVnetFromServerFarm", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVnetFromServerFarmResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetVnetFromServerFarm", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetVnetFromServerFarmPreparer prepares the GetVnetFromServerFarm request.
+func (client AppServicePlansClient) GetVnetFromServerFarmPreparer(resourceGroupName string, name string, vnetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetVnetFromServerFarmSender sends the GetVnetFromServerFarm request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) GetVnetFromServerFarmSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetVnetFromServerFarmResponder handles the response to the GetVnetFromServerFarm request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) GetVnetFromServerFarmResponder(resp *http.Response) (result VnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetVnetGateway get a Virtual Network gateway.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network. gatewayName is name of the gateway. Only the 'primary'
+// gateway is supported.
+func (client AppServicePlansClient) GetVnetGateway(resourceGroupName string, name string, vnetName string, gatewayName string) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "GetVnetGateway")
+ }
+
+ req, err := client.GetVnetGatewayPreparer(resourceGroupName, name, vnetName, gatewayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetVnetGateway", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetVnetGatewaySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetVnetGateway", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetVnetGatewayResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "GetVnetGateway", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetVnetGatewayPreparer prepares the GetVnetGateway request.
+func (client AppServicePlansClient) GetVnetGatewayPreparer(resourceGroupName string, name string, vnetName string, gatewayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetVnetGatewaySender sends the GetVnetGateway request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) GetVnetGatewaySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetVnetGatewayResponder handles the response to the GetVnetGateway request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) GetVnetGatewayResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List get all App Service plans for a subcription.
+//
+// detailed is specify true to return all App Service plan
+// properties. The default is false, which returns a subset of the
+// properties.
+// Retrieval of all properties may increase the API latency.
+func (client AppServicePlansClient) List(detailed *bool) (result AppServicePlanCollection, err error) {
+ req, err := client.ListPreparer(detailed)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client AppServicePlansClient) ListPreparer(detailed *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if detailed != nil {
+ queryParameters["detailed"] = autorest.Encode("query", *detailed)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/serverfarms", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListResponder(resp *http.Response) (result AppServicePlanCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 AppServicePlansClient) ListNextResults(lastResults AppServicePlanCollection) (result AppServicePlanCollection, err error) {
+ req, err := lastResults.AppServicePlanCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "List", 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, "web.AppServicePlansClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListByResourceGroup get all App Service plans in a resource group.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs.
+func (client AppServicePlansClient) ListByResourceGroup(resourceGroupName string) (result AppServicePlanCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListByResourceGroup")
+ }
+
+ req, err := client.ListByResourceGroupPreparer(resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client AppServicePlansClient) ListByResourceGroupPreparer(resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListByResourceGroupResponder(resp *http.Response) (result AppServicePlanCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client AppServicePlansClient) ListByResourceGroupNextResults(lastResults AppServicePlanCollection) (result AppServicePlanCollection, err error) {
+ req, err := lastResults.AppServicePlanCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListByResourceGroup", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListCapabilities list all capabilities of an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan.
+func (client AppServicePlansClient) ListCapabilities(resourceGroupName string, name string) (result ListCapability, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListCapabilities")
+ }
+
+ req, err := client.ListCapabilitiesPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListCapabilities", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListCapabilitiesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListCapabilities", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListCapabilitiesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListCapabilities", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListCapabilitiesPreparer prepares the ListCapabilities request.
+func (client AppServicePlansClient) ListCapabilitiesPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/capabilities", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListCapabilitiesSender sends the ListCapabilities request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListCapabilitiesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListCapabilitiesResponder handles the response to the ListCapabilities request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListCapabilitiesResponder(resp *http.Response) (result ListCapability, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHybridConnectionKeys get the send key name and value of a Hybrid
+// Connection.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. namespaceName is the name of
+// the Service Bus namespace. relayName is the name of the Service Bus relay.
+func (client AppServicePlansClient) ListHybridConnectionKeys(resourceGroupName string, name string, namespaceName string, relayName string) (result HybridConnectionKey, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListHybridConnectionKeys")
+ }
+
+ req, err := client.ListHybridConnectionKeysPreparer(resourceGroupName, name, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnectionKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHybridConnectionKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnectionKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHybridConnectionKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnectionKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHybridConnectionKeysPreparer prepares the ListHybridConnectionKeys request.
+func (client AppServicePlansClient) ListHybridConnectionKeysPreparer(resourceGroupName string, name string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}/listKeys", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHybridConnectionKeysSender sends the ListHybridConnectionKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListHybridConnectionKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHybridConnectionKeysResponder handles the response to the ListHybridConnectionKeys request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListHybridConnectionKeysResponder(resp *http.Response) (result HybridConnectionKey, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHybridConnections retrieve all Hybrid Connections in use in an App
+// Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan.
+func (client AppServicePlansClient) ListHybridConnections(resourceGroupName string, name string) (result HybridConnectionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListHybridConnections")
+ }
+
+ req, err := client.ListHybridConnectionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnections", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHybridConnectionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnections", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHybridConnectionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnections", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHybridConnectionsPreparer prepares the ListHybridConnections request.
+func (client AppServicePlansClient) ListHybridConnectionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/hybridConnectionRelays", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHybridConnectionsSender sends the ListHybridConnections request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListHybridConnectionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHybridConnectionsResponder handles the response to the ListHybridConnections request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListHybridConnectionsResponder(resp *http.Response) (result HybridConnectionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHybridConnectionsNextResults retrieves the next set of results, if any.
+func (client AppServicePlansClient) ListHybridConnectionsNextResults(lastResults HybridConnectionCollection) (result HybridConnectionCollection, err error) {
+ req, err := lastResults.HybridConnectionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnections", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListHybridConnectionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnections", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListHybridConnectionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListHybridConnections", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMetricDefintions get metrics that can be queried for an App Service
+// plan, and their definitions.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan.
+func (client AppServicePlansClient) ListMetricDefintions(resourceGroupName string, name string) (result ResourceMetricDefinitionCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListMetricDefintions")
+ }
+
+ req, err := client.ListMetricDefintionsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetricDefintions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricDefintionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetricDefintions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricDefintionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetricDefintions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricDefintionsPreparer prepares the ListMetricDefintions request.
+func (client AppServicePlansClient) ListMetricDefintionsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/metricdefinitions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricDefintionsSender sends the ListMetricDefintions request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListMetricDefintionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricDefintionsResponder handles the response to the ListMetricDefintions request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListMetricDefintionsResponder(resp *http.Response) (result ResourceMetricDefinitionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricDefintionsNextResults retrieves the next set of results, if any.
+func (client AppServicePlansClient) ListMetricDefintionsNextResults(lastResults ResourceMetricDefinitionCollection) (result ResourceMetricDefinitionCollection, err error) {
+ req, err := lastResults.ResourceMetricDefinitionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetricDefintions", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMetricDefintionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetricDefintions", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMetricDefintionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetricDefintions", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListMetrics get metrics for an App Serice plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. details is specify
+// true to include instance details. The default is
+// false. filter is return only usages/metrics specified in the
+// filter. Filter conforms to odata syntax. Example: $filter=(name.value eq
+// 'Metric1' or name.value eq 'Metric2') and startTime eq
+// '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain
+// eq duration'[Hour|Minute|Day]'.
+func (client AppServicePlansClient) ListMetrics(resourceGroupName string, name string, details *bool, filter string) (result ResourceMetricCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListMetrics")
+ }
+
+ req, err := client.ListMetricsPreparer(resourceGroupName, name, details, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetrics", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetrics", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetrics", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListMetricsPreparer prepares the ListMetrics request.
+func (client AppServicePlansClient) ListMetricsPreparer(resourceGroupName string, name string, details *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if details != nil {
+ queryParameters["details"] = autorest.Encode("query", *details)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/metrics", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListMetricsSender sends the ListMetrics request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListMetricsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListMetricsResponder handles the response to the ListMetrics request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListMetricsResponder(resp *http.Response) (result ResourceMetricCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListMetricsNextResults retrieves the next set of results, if any.
+func (client AppServicePlansClient) ListMetricsNextResults(lastResults ResourceMetricCollection) (result ResourceMetricCollection, err error) {
+ req, err := lastResults.ResourceMetricCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetrics", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListMetricsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetrics", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListMetricsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListMetrics", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListRoutesForVnet get all routes that are associated with a Virtual Network
+// in an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network.
+func (client AppServicePlansClient) ListRoutesForVnet(resourceGroupName string, name string, vnetName string) (result ListVnetRoute, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListRoutesForVnet")
+ }
+
+ req, err := client.ListRoutesForVnetPreparer(resourceGroupName, name, vnetName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListRoutesForVnet", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListRoutesForVnetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListRoutesForVnet", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListRoutesForVnetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListRoutesForVnet", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListRoutesForVnetPreparer prepares the ListRoutesForVnet request.
+func (client AppServicePlansClient) ListRoutesForVnetPreparer(resourceGroupName string, name string, vnetName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}/routes", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListRoutesForVnetSender sends the ListRoutesForVnet request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListRoutesForVnetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListRoutesForVnetResponder handles the response to the ListRoutesForVnet request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListRoutesForVnetResponder(resp *http.Response) (result ListVnetRoute, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListVnets get all Virtual Networks associated with an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan.
+func (client AppServicePlansClient) ListVnets(resourceGroupName string, name string) (result ListVnetInfo, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListVnets")
+ }
+
+ req, err := client.ListVnetsPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListVnets", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListVnetsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListVnets", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListVnetsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListVnets", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListVnetsPreparer prepares the ListVnets request.
+func (client AppServicePlansClient) ListVnetsPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListVnetsSender sends the ListVnets request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListVnetsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListVnetsResponder handles the response to the ListVnets request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListVnetsResponder(resp *http.Response) (result ListVnetInfo, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebApps get all apps associated with an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. skipToken is skip to a web
+// app in the list of webapps associated with app service plan. If specified,
+// the resulting list will contain web apps starting from (including) the
+// skipToken. Otherwise, the resulting list contains web apps from the start of
+// the list filter is supported filter: $filter=state eq running. Returns only
+// web apps that are currently running top is list page size. If specified,
+// results are paged.
+func (client AppServicePlansClient) ListWebApps(resourceGroupName string, name string, skipToken string, filter string, top string) (result AppCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListWebApps")
+ }
+
+ req, err := client.ListWebAppsPreparer(resourceGroupName, name, skipToken, filter, top)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebApps", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWebAppsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebApps", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWebAppsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebApps", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWebAppsPreparer prepares the ListWebApps request.
+func (client AppServicePlansClient) ListWebAppsPreparer(resourceGroupName string, name string, skipToken string, filter string, top string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(skipToken) > 0 {
+ queryParameters["$skipToken"] = autorest.Encode("query", skipToken)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+ if len(top) > 0 {
+ queryParameters["$top"] = autorest.Encode("query", top)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/sites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWebAppsSender sends the ListWebApps request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListWebAppsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWebAppsResponder handles the response to the ListWebApps request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListWebAppsResponder(resp *http.Response) (result AppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebAppsNextResults retrieves the next set of results, if any.
+func (client AppServicePlansClient) ListWebAppsNextResults(lastResults AppCollection) (result AppCollection, err error) {
+ req, err := lastResults.AppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebApps", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWebAppsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebApps", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWebAppsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebApps", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListWebAppsByHybridConnection get all apps that use a Hybrid Connection in
+// an App Service Plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. namespaceName is name of the
+// Hybrid Connection namespace. relayName is name of the Hybrid Connection
+// relay.
+func (client AppServicePlansClient) ListWebAppsByHybridConnection(resourceGroupName string, name string, namespaceName string, relayName string) (result ResourceCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "ListWebAppsByHybridConnection")
+ }
+
+ req, err := client.ListWebAppsByHybridConnectionPreparer(resourceGroupName, name, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebAppsByHybridConnection", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListWebAppsByHybridConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebAppsByHybridConnection", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListWebAppsByHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebAppsByHybridConnection", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListWebAppsByHybridConnectionPreparer prepares the ListWebAppsByHybridConnection request.
+func (client AppServicePlansClient) ListWebAppsByHybridConnectionPreparer(resourceGroupName string, name string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/hybridConnectionNamespaces/{namespaceName}/relays/{relayName}/sites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListWebAppsByHybridConnectionSender sends the ListWebAppsByHybridConnection request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) ListWebAppsByHybridConnectionSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListWebAppsByHybridConnectionResponder handles the response to the ListWebAppsByHybridConnection request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) ListWebAppsByHybridConnectionResponder(resp *http.Response) (result ResourceCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListWebAppsByHybridConnectionNextResults retrieves the next set of results, if any.
+func (client AppServicePlansClient) ListWebAppsByHybridConnectionNextResults(lastResults ResourceCollection) (result ResourceCollection, err error) {
+ req, err := lastResults.ResourceCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebAppsByHybridConnection", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListWebAppsByHybridConnectionSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebAppsByHybridConnection", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListWebAppsByHybridConnectionResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "ListWebAppsByHybridConnection", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// RebootWorker reboot a worker machine in an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. workerName is name of worker
+// machine, which typically starts with RD.
+func (client AppServicePlansClient) RebootWorker(resourceGroupName string, name string, workerName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "RebootWorker")
+ }
+
+ req, err := client.RebootWorkerPreparer(resourceGroupName, name, workerName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "RebootWorker", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RebootWorkerSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "RebootWorker", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RebootWorkerResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "RebootWorker", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RebootWorkerPreparer prepares the RebootWorker request.
+func (client AppServicePlansClient) RebootWorkerPreparer(resourceGroupName string, name string, workerName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "workerName": autorest.Encode("path", workerName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/workers/{workerName}/reboot", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RebootWorkerSender sends the RebootWorker request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) RebootWorkerSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RebootWorkerResponder handles the response to the RebootWorker request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) RebootWorkerResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// RestartWebApps restart all apps in an App Service plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. softRestart is specify
+// true to performa a soft restart, applies the configuration
+// settings and restarts the apps if necessary. The default is
+// false, which always restarts and reprovisions the apps
+func (client AppServicePlansClient) RestartWebApps(resourceGroupName string, name string, softRestart *bool) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "RestartWebApps")
+ }
+
+ req, err := client.RestartWebAppsPreparer(resourceGroupName, name, softRestart)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "RestartWebApps", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RestartWebAppsSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "RestartWebApps", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RestartWebAppsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "RestartWebApps", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RestartWebAppsPreparer prepares the RestartWebApps request.
+func (client AppServicePlansClient) RestartWebAppsPreparer(resourceGroupName string, name string, softRestart *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if softRestart != nil {
+ queryParameters["softRestart"] = autorest.Encode("query", *softRestart)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/restartSites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// RestartWebAppsSender sends the RestartWebApps request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) RestartWebAppsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// RestartWebAppsResponder handles the response to the RestartWebApps request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) RestartWebAppsResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// UpdateVnetGateway update a Virtual Network gateway.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network. gatewayName is name of the gateway. Only the 'primary'
+// gateway is supported. connectionEnvelope is definition of the gateway.
+func (client AppServicePlansClient) UpdateVnetGateway(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway) (result VnetGateway, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "UpdateVnetGateway")
+ }
+
+ req, err := client.UpdateVnetGatewayPreparer(resourceGroupName, name, vnetName, gatewayName, connectionEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "UpdateVnetGateway", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateVnetGatewaySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "UpdateVnetGateway", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateVnetGatewayResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "UpdateVnetGateway", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateVnetGatewayPreparer prepares the UpdateVnetGateway request.
+func (client AppServicePlansClient) UpdateVnetGatewayPreparer(resourceGroupName string, name string, vnetName string, gatewayName string, connectionEnvelope VnetGateway) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "gatewayName": autorest.Encode("path", gatewayName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}/gateways/{gatewayName}", pathParameters),
+ autorest.WithJSON(connectionEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateVnetGatewaySender sends the UpdateVnetGateway request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) UpdateVnetGatewaySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateVnetGatewayResponder handles the response to the UpdateVnetGateway request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) UpdateVnetGatewayResponder(resp *http.Response) (result VnetGateway, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateVnetRoute create or update a Virtual Network route in an App Service
+// plan.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the App Service plan. vnetName is name of the
+// Virtual Network. routeName is name of the Virtual Network route. route is
+// definition of the Virtual Network route.
+func (client AppServicePlansClient) UpdateVnetRoute(resourceGroupName string, name string, vnetName string, routeName string, route VnetRoute) (result VnetRoute, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.AppServicePlansClient", "UpdateVnetRoute")
+ }
+
+ req, err := client.UpdateVnetRoutePreparer(resourceGroupName, name, vnetName, routeName, route)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "UpdateVnetRoute", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateVnetRouteSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "UpdateVnetRoute", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateVnetRouteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.AppServicePlansClient", "UpdateVnetRoute", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateVnetRoutePreparer prepares the UpdateVnetRoute request.
+func (client AppServicePlansClient) UpdateVnetRoutePreparer(resourceGroupName string, name string, vnetName string, routeName string, route VnetRoute) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "routeName": autorest.Encode("path", routeName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ "vnetName": autorest.Encode("path", vnetName),
+ }
+
+ const APIVersion = "2016-09-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/serverfarms/{name}/virtualNetworkConnections/{vnetName}/routes/{routeName}", pathParameters),
+ autorest.WithJSON(route),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateVnetRouteSender sends the UpdateVnetRoute request. The method will close the
+// http.Response Body if it receives an error.
+func (client AppServicePlansClient) UpdateVnetRouteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateVnetRouteResponder handles the response to the UpdateVnetRoute request. The method always
+// closes the http.Response Body.
+func (client AppServicePlansClient) UpdateVnetRouteResponder(resp *http.Response) (result VnetRoute, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusBadRequest, http.StatusNotFound),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/certificates.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/certificates.go
new file mode 100755
index 000000000000..19628ccd82d6
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/certificates.go
@@ -0,0 +1,525 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// CertificatesClient is the composite Swagger for WebSite Management Client
+type CertificatesClient struct {
+ ManagementClient
+}
+
+// NewCertificatesClient creates an instance of the CertificatesClient client.
+func NewCertificatesClient(subscriptionID string) CertificatesClient {
+ return NewCertificatesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewCertificatesClientWithBaseURI creates an instance of the
+// CertificatesClient client.
+func NewCertificatesClientWithBaseURI(baseURI string, subscriptionID string) CertificatesClient {
+ return CertificatesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate create or update a certificate.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the certificate. certificateEnvelope is details of
+// certificate, if it exists already.
+func (client CertificatesClient) CreateOrUpdate(resourceGroupName string, name string, certificateEnvelope Certificate) (result Certificate, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.CertificatesClient", "CreateOrUpdate")
+ }
+
+ req, err := client.CreateOrUpdatePreparer(resourceGroupName, name, certificateEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client CertificatesClient) CreateOrUpdatePreparer(resourceGroupName string, name string, certificateEnvelope Certificate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/certificates/{name}", pathParameters),
+ autorest.WithJSON(certificateEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client CertificatesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client CertificatesClient) CreateOrUpdateResponder(resp *http.Response) (result Certificate, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete delete a certificate.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the certificate.
+func (client CertificatesClient) Delete(resourceGroupName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.CertificatesClient", "Delete")
+ }
+
+ req, err := client.DeletePreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Delete", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client CertificatesClient) DeletePreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/certificates/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client CertificatesClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client CertificatesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get get a certificate.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the certificate.
+func (client CertificatesClient) Get(resourceGroupName string, name string) (result Certificate, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.CertificatesClient", "Get")
+ }
+
+ req, err := client.GetPreparer(resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client CertificatesClient) GetPreparer(resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/certificates/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client CertificatesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client CertificatesClient) GetResponder(resp *http.Response) (result Certificate, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List get all certificates for a subscription.
+func (client CertificatesClient) List() (result CertificateCollection, err error) {
+ req, err := client.ListPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client CertificatesClient) ListPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/certificates", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client CertificatesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client CertificatesClient) ListResponder(resp *http.Response) (result CertificateCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 CertificatesClient) ListNextResults(lastResults CertificateCollection) (result CertificateCollection, err error) {
+ req, err := lastResults.CertificateCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.CertificatesClient", "List", 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, "web.CertificatesClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListByResourceGroup get all certificates in a resource group.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs.
+func (client CertificatesClient) ListByResourceGroup(resourceGroupName string) (result CertificateCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.CertificatesClient", "ListByResourceGroup")
+ }
+
+ req, err := client.ListByResourceGroupPreparer(resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client CertificatesClient) ListByResourceGroupPreparer(resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/certificates", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client CertificatesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client CertificatesClient) ListByResourceGroupResponder(resp *http.Response) (result CertificateCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client CertificatesClient) ListByResourceGroupNextResults(lastResults CertificateCollection) (result CertificateCollection, err error) {
+ req, err := lastResults.CertificateCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.CertificatesClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.CertificatesClient", "ListByResourceGroup", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// Update create or update a certificate.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. name is name of the certificate. certificateEnvelope is details of
+// certificate, if it exists already.
+func (client CertificatesClient) Update(resourceGroupName string, name string, certificateEnvelope Certificate) (result Certificate, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.CertificatesClient", "Update")
+ }
+
+ req, err := client.UpdatePreparer(resourceGroupName, name, certificateEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Update", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.CertificatesClient", "Update", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client CertificatesClient) UpdatePreparer(resourceGroupName string, name string, certificateEnvelope Certificate) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/certificates/{name}", pathParameters),
+ autorest.WithJSON(certificateEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client CertificatesClient) UpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client CertificatesClient) UpdateResponder(resp *http.Response) (result Certificate, 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/Azure/azure-sdk-for-go/arm/web/client.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/client.go
new file mode 100755
index 000000000000..379919c744f8
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/client.go
@@ -0,0 +1,876 @@
+// Package web implements the Azure ARM Web service API version .
+//
+// Composite Swagger for WebSite Management Client
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+const (
+ // DefaultBaseURI is the default URI used for the service Web
+ DefaultBaseURI = "https://management.azure.com"
+)
+
+// ManagementClient is the base client for Web.
+type ManagementClient struct {
+ autorest.Client
+ BaseURI string
+ SubscriptionID string
+}
+
+// New creates an instance of the ManagementClient client.
+func New(subscriptionID string) ManagementClient {
+ return NewWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWithBaseURI creates an instance of the ManagementClient client.
+func NewWithBaseURI(baseURI string, subscriptionID string) ManagementClient {
+ return ManagementClient{
+ Client: autorest.NewClientWithUserAgent(UserAgent()),
+ BaseURI: baseURI,
+ SubscriptionID: subscriptionID,
+ }
+}
+
+// CheckNameAvailability check if a resource name is available.
+//
+// request is name availability request.
+func (client ManagementClient) CheckNameAvailability(request ResourceNameAvailabilityRequest) (result ResourceNameAvailability, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: request,
+ Constraints: []validation.Constraint{{Target: "request.Name", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.ManagementClient", "CheckNameAvailability")
+ }
+
+ req, err := client.CheckNameAvailabilityPreparer(request)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "CheckNameAvailability", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CheckNameAvailabilitySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "CheckNameAvailability", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CheckNameAvailabilityResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "CheckNameAvailability", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request.
+func (client ManagementClient) CheckNameAvailabilityPreparer(request ResourceNameAvailabilityRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/checknameavailability", pathParameters),
+ autorest.WithJSON(request),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) CheckNameAvailabilityResponder(resp *http.Response) (result ResourceNameAvailability, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetPublishingUser gets publishing user
+func (client ManagementClient) GetPublishingUser() (result User, err error) {
+ req, err := client.GetPublishingUserPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "GetPublishingUser", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetPublishingUserSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "GetPublishingUser", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetPublishingUserResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "GetPublishingUser", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPublishingUserPreparer prepares the GetPublishingUser request.
+func (client ManagementClient) GetPublishingUserPreparer() (*http.Request, error) {
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Web/publishingUsers/web"),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetPublishingUserSender sends the GetPublishingUser request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) GetPublishingUserSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetPublishingUserResponder handles the response to the GetPublishingUser request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) GetPublishingUserResponder(resp *http.Response) (result User, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListGeoRegions get a list of available geographical regions.
+//
+// sku is name of SKU used to filter the regions. linuxWorkersEnabled is
+// specify true if you want to filter to only regions that support
+// Linux workers.
+func (client ManagementClient) ListGeoRegions(sku SkuName, linuxWorkersEnabled *bool) (result GeoRegionCollection, err error) {
+ req, err := client.ListGeoRegionsPreparer(sku, linuxWorkersEnabled)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListGeoRegions", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListGeoRegionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListGeoRegions", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListGeoRegionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListGeoRegions", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListGeoRegionsPreparer prepares the ListGeoRegions request.
+func (client ManagementClient) ListGeoRegionsPreparer(sku SkuName, linuxWorkersEnabled *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(string(sku)) > 0 {
+ queryParameters["sku"] = autorest.Encode("query", sku)
+ }
+ if linuxWorkersEnabled != nil {
+ queryParameters["linuxWorkersEnabled"] = autorest.Encode("query", *linuxWorkersEnabled)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/geoRegions", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListGeoRegionsSender sends the ListGeoRegions request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) ListGeoRegionsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListGeoRegionsResponder handles the response to the ListGeoRegions request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) ListGeoRegionsResponder(resp *http.Response) (result GeoRegionCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListGeoRegionsNextResults retrieves the next set of results, if any.
+func (client ManagementClient) ListGeoRegionsNextResults(lastResults GeoRegionCollection) (result GeoRegionCollection, err error) {
+ req, err := lastResults.GeoRegionCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.ManagementClient", "ListGeoRegions", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListGeoRegionsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.ManagementClient", "ListGeoRegions", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListGeoRegionsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListGeoRegions", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListPremierAddOnOffers list all premier add-on offers.
+func (client ManagementClient) ListPremierAddOnOffers() (result PremierAddOnOfferCollection, err error) {
+ req, err := client.ListPremierAddOnOffersPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListPremierAddOnOffers", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListPremierAddOnOffersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListPremierAddOnOffers", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListPremierAddOnOffersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListPremierAddOnOffers", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPremierAddOnOffersPreparer prepares the ListPremierAddOnOffers request.
+func (client ManagementClient) ListPremierAddOnOffersPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/premieraddonoffers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListPremierAddOnOffersSender sends the ListPremierAddOnOffers request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) ListPremierAddOnOffersSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListPremierAddOnOffersResponder handles the response to the ListPremierAddOnOffers request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) ListPremierAddOnOffersResponder(resp *http.Response) (result PremierAddOnOfferCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListPremierAddOnOffersNextResults retrieves the next set of results, if any.
+func (client ManagementClient) ListPremierAddOnOffersNextResults(lastResults PremierAddOnOfferCollection) (result PremierAddOnOfferCollection, err error) {
+ req, err := lastResults.PremierAddOnOfferCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.ManagementClient", "ListPremierAddOnOffers", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListPremierAddOnOffersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.ManagementClient", "ListPremierAddOnOffers", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListPremierAddOnOffersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListPremierAddOnOffers", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListSkus list all SKUs.
+func (client ManagementClient) ListSkus() (result SkuInfos, err error) {
+ req, err := client.ListSkusPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListSkus", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSkusSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListSkus", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSkusResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListSkus", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSkusPreparer prepares the ListSkus request.
+func (client ManagementClient) ListSkusPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/skus", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSkusSender sends the ListSkus request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) ListSkusSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSkusResponder handles the response to the ListSkus request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) ListSkusResponder(resp *http.Response) (result SkuInfos, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSourceControls gets the source controls available for Azure websites.
+func (client ManagementClient) ListSourceControls() (result SourceControlCollection, err error) {
+ req, err := client.ListSourceControlsPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListSourceControls", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSourceControlsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListSourceControls", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListSourceControlsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListSourceControls", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListSourceControlsPreparer prepares the ListSourceControls request.
+func (client ManagementClient) ListSourceControlsPreparer() (*http.Request, error) {
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Web/sourcecontrols"),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSourceControlsSender sends the ListSourceControls request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) ListSourceControlsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListSourceControlsResponder handles the response to the ListSourceControls request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) ListSourceControlsResponder(resp *http.Response) (result SourceControlCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListSourceControlsNextResults retrieves the next set of results, if any.
+func (client ManagementClient) ListSourceControlsNextResults(lastResults SourceControlCollection) (result SourceControlCollection, err error) {
+ req, err := lastResults.SourceControlCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.ManagementClient", "ListSourceControls", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListSourceControlsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.ManagementClient", "ListSourceControls", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListSourceControlsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ListSourceControls", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// Move move resources between resource groups.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. moveResourceEnvelope is object that represents the resource to
+// move.
+func (client ManagementClient) Move(resourceGroupName string, moveResourceEnvelope CsmMoveResourceEnvelope) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: moveResourceEnvelope,
+ Constraints: []validation.Constraint{{Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.Pattern, Rule: ` ^[-\w\._\(\)]+[^\.]$`, Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.ManagementClient", "Move")
+ }
+
+ req, err := client.MovePreparer(resourceGroupName, moveResourceEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "Move", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.MoveSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "Move", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.MoveResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "Move", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// MovePreparer prepares the Move request.
+func (client ManagementClient) MovePreparer(resourceGroupName string, moveResourceEnvelope CsmMoveResourceEnvelope) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/moveResources", pathParameters),
+ autorest.WithJSON(moveResourceEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// MoveSender sends the Move request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) MoveSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// MoveResponder handles the response to the Move request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) MoveResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// UpdatePublishingUser updates publishing user
+//
+// userDetails is details of publishing user
+func (client ManagementClient) UpdatePublishingUser(userDetails User) (result User, err error) {
+ req, err := client.UpdatePublishingUserPreparer(userDetails)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "UpdatePublishingUser", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdatePublishingUserSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "UpdatePublishingUser", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdatePublishingUserResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "UpdatePublishingUser", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdatePublishingUserPreparer prepares the UpdatePublishingUser request.
+func (client ManagementClient) UpdatePublishingUserPreparer(userDetails User) (*http.Request, error) {
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Web/publishingUsers/web"),
+ autorest.WithJSON(userDetails),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdatePublishingUserSender sends the UpdatePublishingUser request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) UpdatePublishingUserSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdatePublishingUserResponder handles the response to the UpdatePublishingUser request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) UpdatePublishingUserResponder(resp *http.Response) (result User, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// UpdateSourceControl updates source control token
+//
+// sourceControlType is type of source control requestMessage is source control
+// token information
+func (client ManagementClient) UpdateSourceControl(sourceControlType string, requestMessage SourceControl) (result SourceControl, err error) {
+ req, err := client.UpdateSourceControlPreparer(sourceControlType, requestMessage)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "UpdateSourceControl", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSourceControlSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "UpdateSourceControl", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateSourceControlResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "UpdateSourceControl", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateSourceControlPreparer prepares the UpdateSourceControl request.
+func (client ManagementClient) UpdateSourceControlPreparer(sourceControlType string, requestMessage SourceControl) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "sourceControlType": autorest.Encode("path", sourceControlType),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/providers/Microsoft.Web/sourcecontrols/{sourceControlType}", pathParameters),
+ autorest.WithJSON(requestMessage),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateSourceControlSender sends the UpdateSourceControl request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) UpdateSourceControlSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateSourceControlResponder handles the response to the UpdateSourceControl request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) UpdateSourceControlResponder(resp *http.Response) (result SourceControl, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Validate validate if a resource can be created.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. validateRequest is request with the resources to validate.
+func (client ManagementClient) Validate(resourceGroupName string, validateRequest ValidateRequest) (result ValidateResponse, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: validateRequest,
+ Constraints: []validation.Constraint{{Target: "validateRequest.Name", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "validateRequest.Location", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "validateRequest.ValidateProperties", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "validateRequest.ValidateProperties.Capacity", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "validateRequest.ValidateProperties.Capacity", Name: validation.InclusiveMinimum, Rule: 1, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.ManagementClient", "Validate")
+ }
+
+ req, err := client.ValidatePreparer(resourceGroupName, validateRequest)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "Validate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ValidateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "Validate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ValidateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "Validate", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ValidatePreparer prepares the Validate request.
+func (client ManagementClient) ValidatePreparer(resourceGroupName string, validateRequest ValidateRequest) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/validate", pathParameters),
+ autorest.WithJSON(validateRequest),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ValidateSender sends the Validate request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) ValidateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ValidateResponder handles the response to the Validate request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) ValidateResponder(resp *http.Response) (result ValidateResponse, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ValidateMove validate whether a resource can be moved.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. moveResourceEnvelope is object that represents the resource to
+// move.
+func (client ManagementClient) ValidateMove(resourceGroupName string, moveResourceEnvelope CsmMoveResourceEnvelope) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: moveResourceEnvelope,
+ Constraints: []validation.Constraint{{Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "moveResourceEnvelope.TargetResourceGroup", Name: validation.Pattern, Rule: ` ^[-\w\._\(\)]+[^\.]$`, Chain: nil},
+ }}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.ManagementClient", "ValidateMove")
+ }
+
+ req, err := client.ValidateMovePreparer(resourceGroupName, moveResourceEnvelope)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ValidateMove", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ValidateMoveSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ValidateMove", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ValidateMoveResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ManagementClient", "ValidateMove", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ValidateMovePreparer prepares the ValidateMove request.
+func (client ManagementClient) ValidateMovePreparer(resourceGroupName string, moveResourceEnvelope CsmMoveResourceEnvelope) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/validateMoveResources", pathParameters),
+ autorest.WithJSON(moveResourceEnvelope),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ValidateMoveSender sends the ValidateMove request. The method will close the
+// http.Response Body if it receives an error.
+func (client ManagementClient) ValidateMoveSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ValidateMoveResponder handles the response to the ValidateMove request. The method always
+// closes the http.Response Body.
+func (client ManagementClient) ValidateMoveResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/deletedwebapps.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/deletedwebapps.go
new file mode 100755
index 000000000000..7ea24e8ab64a
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/deletedwebapps.go
@@ -0,0 +1,225 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// DeletedWebAppsClient is the composite Swagger for WebSite Management Client
+type DeletedWebAppsClient struct {
+ ManagementClient
+}
+
+// NewDeletedWebAppsClient creates an instance of the DeletedWebAppsClient
+// client.
+func NewDeletedWebAppsClient(subscriptionID string) DeletedWebAppsClient {
+ return NewDeletedWebAppsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewDeletedWebAppsClientWithBaseURI creates an instance of the
+// DeletedWebAppsClient client.
+func NewDeletedWebAppsClientWithBaseURI(baseURI string, subscriptionID string) DeletedWebAppsClient {
+ return DeletedWebAppsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List get all deleted apps for a subscription.
+func (client DeletedWebAppsClient) List() (result DeletedWebAppCollection, err error) {
+ req, err := client.ListPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client DeletedWebAppsClient) ListPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/deletedSites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client DeletedWebAppsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client DeletedWebAppsClient) ListResponder(resp *http.Response) (result DeletedWebAppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 DeletedWebAppsClient) ListNextResults(lastResults DeletedWebAppCollection) (result DeletedWebAppCollection, err error) {
+ req, err := lastResults.DeletedWebAppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "List", 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, "web.DeletedWebAppsClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListByResourceGroup gets deleted web apps in subscription.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs.
+func (client DeletedWebAppsClient) ListByResourceGroup(resourceGroupName string) (result DeletedWebAppCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DeletedWebAppsClient", "ListByResourceGroup")
+ }
+
+ req, err := client.ListByResourceGroupPreparer(resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client DeletedWebAppsClient) ListByResourceGroupPreparer(resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/deletedSites", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client DeletedWebAppsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client DeletedWebAppsClient) ListByResourceGroupResponder(resp *http.Response) (result DeletedWebAppCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client DeletedWebAppsClient) ListByResourceGroupNextResults(lastResults DeletedWebAppCollection) (result DeletedWebAppCollection, err error) {
+ req, err := lastResults.DeletedWebAppCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "ListByResourceGroup", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DeletedWebAppsClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+ }
+
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/domains.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/domains.go
new file mode 100755
index 000000000000..fba3c1d1fe04
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/domains.go
@@ -0,0 +1,1151 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// DomainsClient is the composite Swagger for WebSite Management Client
+type DomainsClient struct {
+ ManagementClient
+}
+
+// NewDomainsClient creates an instance of the DomainsClient client.
+func NewDomainsClient(subscriptionID string) DomainsClient {
+ return NewDomainsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewDomainsClientWithBaseURI creates an instance of the DomainsClient client.
+func NewDomainsClientWithBaseURI(baseURI string, subscriptionID string) DomainsClient {
+ return DomainsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CheckAvailability check if a domain is available for registration.
+//
+// identifier is name of the domain.
+func (client DomainsClient) CheckAvailability(identifier NameIdentifier) (result DomainAvailablilityCheckResult, err error) {
+ req, err := client.CheckAvailabilityPreparer(identifier)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CheckAvailability", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CheckAvailabilitySender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CheckAvailability", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CheckAvailabilityResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CheckAvailability", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CheckAvailabilityPreparer prepares the CheckAvailability request.
+func (client DomainsClient) CheckAvailabilityPreparer(identifier NameIdentifier) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/checkDomainAvailability", pathParameters),
+ autorest.WithJSON(identifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CheckAvailabilitySender sends the CheckAvailability request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) CheckAvailabilitySender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CheckAvailabilityResponder handles the response to the CheckAvailability request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) CheckAvailabilityResponder(resp *http.Response) (result DomainAvailablilityCheckResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdate creates or updates a domain. This method may poll for
+// completion. Polling can be canceled by passing the cancel channel argument.
+// The channel will be used to cancel polling and any outstanding HTTP
+// requests.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of the domain. domain is domain registration
+// information.
+func (client DomainsClient) CreateOrUpdate(resourceGroupName string, domainName string, domain Domain, cancel <-chan struct{}) (<-chan Domain, <-chan error) {
+ resultChan := make(chan Domain, 1)
+ errChan := make(chan error, 1)
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}},
+ {TargetValue: domainName,
+ Constraints: []validation.Constraint{{Target: "domainName", Name: validation.Pattern, Rule: `[a-zA-Z0-9][a-zA-Z0-9\.-]+`, Chain: nil}}},
+ {TargetValue: domain,
+ Constraints: []validation.Constraint{{Target: "domain.DomainProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactAdmin", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactAdmin.AddressMailing", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactAdmin.AddressMailing.Address1", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactAdmin.AddressMailing.City", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactAdmin.AddressMailing.Country", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactAdmin.AddressMailing.PostalCode", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactAdmin.AddressMailing.State", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "domain.DomainProperties.ContactAdmin.Email", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactAdmin.NameFirst", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactAdmin.NameLast", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactAdmin.Phone", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "domain.DomainProperties.ContactBilling", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactBilling.AddressMailing", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactBilling.AddressMailing.Address1", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactBilling.AddressMailing.City", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactBilling.AddressMailing.Country", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactBilling.AddressMailing.PostalCode", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactBilling.AddressMailing.State", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "domain.DomainProperties.ContactBilling.Email", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactBilling.NameFirst", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactBilling.NameLast", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactBilling.Phone", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "domain.DomainProperties.ContactRegistrant", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactRegistrant.AddressMailing", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactRegistrant.AddressMailing.Address1", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactRegistrant.AddressMailing.City", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactRegistrant.AddressMailing.Country", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactRegistrant.AddressMailing.PostalCode", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactRegistrant.AddressMailing.State", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "domain.DomainProperties.ContactRegistrant.Email", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactRegistrant.NameFirst", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactRegistrant.NameLast", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactRegistrant.Phone", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "domain.DomainProperties.ContactTech", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactTech.AddressMailing", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "domain.DomainProperties.ContactTech.AddressMailing.Address1", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactTech.AddressMailing.City", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactTech.AddressMailing.Country", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactTech.AddressMailing.PostalCode", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactTech.AddressMailing.State", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ {Target: "domain.DomainProperties.ContactTech.Email", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactTech.NameFirst", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactTech.NameLast", Name: validation.Null, Rule: true, Chain: nil},
+ {Target: "domain.DomainProperties.ContactTech.Phone", Name: validation.Null, Rule: true, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ errChan <- validation.NewErrorWithValidationError(err, "web.DomainsClient", "CreateOrUpdate")
+ close(errChan)
+ close(resultChan)
+ return resultChan, errChan
+ }
+
+ go func() {
+ var err error
+ var result Domain
+ defer func() {
+ resultChan <- result
+ errChan <- err
+ close(resultChan)
+ close(errChan)
+ }()
+ req, err := client.CreateOrUpdatePreparer(resourceGroupName, domainName, domain, cancel)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+ }()
+ return resultChan, errChan
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client DomainsClient) CreateOrUpdatePreparer(resourceGroupName string, domainName string, domain Domain, cancel <-chan struct{}) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}", pathParameters),
+ autorest.WithJSON(domain),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{Cancel: cancel})
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client,
+ req,
+ azure.DoPollForAsynchronous(client.PollingDelay))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) CreateOrUpdateResponder(resp *http.Response) (result Domain, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusAccepted, http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateOwnershipIdentifier creates an ownership identifier for a
+// domain or updates identifier details for an existing identifer
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of domain. name is name of identifier.
+// domainOwnershipIdentifier is a JSON representation of the domain ownership
+// properties.
+func (client DomainsClient) CreateOrUpdateOwnershipIdentifier(resourceGroupName string, domainName string, name string, domainOwnershipIdentifier DomainOwnershipIdentifier) (result DomainOwnershipIdentifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "CreateOrUpdateOwnershipIdentifier")
+ }
+
+ req, err := client.CreateOrUpdateOwnershipIdentifierPreparer(resourceGroupName, domainName, name, domainOwnershipIdentifier)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdateOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdateOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdateOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateOwnershipIdentifierPreparer prepares the CreateOrUpdateOwnershipIdentifier request.
+func (client DomainsClient) CreateOrUpdateOwnershipIdentifierPreparer(resourceGroupName string, domainName string, name string, domainOwnershipIdentifier DomainOwnershipIdentifier) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}/domainOwnershipIdentifiers/{name}", pathParameters),
+ autorest.WithJSON(domainOwnershipIdentifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// CreateOrUpdateOwnershipIdentifierSender sends the CreateOrUpdateOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) CreateOrUpdateOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// CreateOrUpdateOwnershipIdentifierResponder handles the response to the CreateOrUpdateOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) CreateOrUpdateOwnershipIdentifierResponder(resp *http.Response) (result DomainOwnershipIdentifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Delete delete a domain.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of the domain. forceHardDeleteDomain is specify
+// true to delete the domain immediately. The default is
+// false which deletes the domain after 24 hours.
+func (client DomainsClient) Delete(resourceGroupName string, domainName string, forceHardDeleteDomain *bool) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "Delete")
+ }
+
+ req, err := client.DeletePreparer(resourceGroupName, domainName, forceHardDeleteDomain)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "Delete", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client DomainsClient) DeletePreparer(resourceGroupName string, domainName string, forceHardDeleteDomain *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if forceHardDeleteDomain != nil {
+ queryParameters["forceHardDeleteDomain"] = autorest.Encode("query", *forceHardDeleteDomain)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteOwnershipIdentifier delete ownership identifier for domain
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of domain. name is name of identifier.
+func (client DomainsClient) DeleteOwnershipIdentifier(resourceGroupName string, domainName string, name string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "DeleteOwnershipIdentifier")
+ }
+
+ req, err := client.DeleteOwnershipIdentifierPreparer(resourceGroupName, domainName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "DeleteOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "DeleteOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "DeleteOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteOwnershipIdentifierPreparer prepares the DeleteOwnershipIdentifier request.
+func (client DomainsClient) DeleteOwnershipIdentifierPreparer(resourceGroupName string, domainName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsDelete(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}/domainOwnershipIdentifiers/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DeleteOwnershipIdentifierSender sends the DeleteOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) DeleteOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DeleteOwnershipIdentifierResponder handles the response to the DeleteOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) DeleteOwnershipIdentifierResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// Get get a domain.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of the domain.
+func (client DomainsClient) Get(resourceGroupName string, domainName string) (result Domain, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "Get")
+ }
+
+ req, err := client.GetPreparer(resourceGroupName, domainName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client DomainsClient) GetPreparer(resourceGroupName string, domainName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) GetResponder(resp *http.Response) (result Domain, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetControlCenterSsoRequest generate a single sign-on request for the domain
+// management portal.
+func (client DomainsClient) GetControlCenterSsoRequest() (result DomainControlCenterSsoRequest, err error) {
+ req, err := client.GetControlCenterSsoRequestPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetControlCenterSsoRequest", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetControlCenterSsoRequestSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetControlCenterSsoRequest", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetControlCenterSsoRequestResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetControlCenterSsoRequest", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetControlCenterSsoRequestPreparer prepares the GetControlCenterSsoRequest request.
+func (client DomainsClient) GetControlCenterSsoRequestPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/generateSsoRequest", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetControlCenterSsoRequestSender sends the GetControlCenterSsoRequest request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) GetControlCenterSsoRequestSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetControlCenterSsoRequestResponder handles the response to the GetControlCenterSsoRequest request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) GetControlCenterSsoRequestResponder(resp *http.Response) (result DomainControlCenterSsoRequest, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetOwnershipIdentifier get ownership identifier for domain
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of domain. name is name of identifier.
+func (client DomainsClient) GetOwnershipIdentifier(resourceGroupName string, domainName string, name string) (result DomainOwnershipIdentifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "GetOwnershipIdentifier")
+ }
+
+ req, err := client.GetOwnershipIdentifierPreparer(resourceGroupName, domainName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetOwnershipIdentifierPreparer prepares the GetOwnershipIdentifier request.
+func (client DomainsClient) GetOwnershipIdentifierPreparer(resourceGroupName string, domainName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}/domainOwnershipIdentifiers/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetOwnershipIdentifierSender sends the GetOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) GetOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetOwnershipIdentifierResponder handles the response to the GetOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) GetOwnershipIdentifierResponder(resp *http.Response) (result DomainOwnershipIdentifier, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List get all domains in a subscription.
+func (client DomainsClient) List() (result DomainCollection, err error) {
+ req, err := client.ListPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client DomainsClient) ListPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/domains", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) ListResponder(resp *http.Response) (result DomainCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 DomainsClient) ListNextResults(lastResults DomainCollection) (result DomainCollection, err error) {
+ req, err := lastResults.DomainCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.DomainsClient", "List", 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, "web.DomainsClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListByResourceGroup get all domains in a resource group.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs.
+func (client DomainsClient) ListByResourceGroup(resourceGroupName string) (result DomainCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "ListByResourceGroup")
+ }
+
+ req, err := client.ListByResourceGroupPreparer(resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client DomainsClient) ListByResourceGroupPreparer(resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) ListByResourceGroupResponder(resp *http.Response) (result DomainCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListByResourceGroupNextResults retrieves the next set of results, if any.
+func (client DomainsClient) ListByResourceGroupNextResults(lastResults DomainCollection) (result DomainCollection, err error) {
+ req, err := lastResults.DomainCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.DomainsClient", "ListByResourceGroup", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.DomainsClient", "ListByResourceGroup", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListByResourceGroup", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListOwnershipIdentifiers lists domain ownership identifiers.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of domain.
+func (client DomainsClient) ListOwnershipIdentifiers(resourceGroupName string, domainName string) (result DomainOwnershipIdentifierCollection, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "ListOwnershipIdentifiers")
+ }
+
+ req, err := client.ListOwnershipIdentifiersPreparer(resourceGroupName, domainName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListOwnershipIdentifiers", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListOwnershipIdentifiersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListOwnershipIdentifiers", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListOwnershipIdentifiersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListOwnershipIdentifiers", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListOwnershipIdentifiersPreparer prepares the ListOwnershipIdentifiers request.
+func (client DomainsClient) ListOwnershipIdentifiersPreparer(resourceGroupName string, domainName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}/domainOwnershipIdentifiers", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListOwnershipIdentifiersSender sends the ListOwnershipIdentifiers request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) ListOwnershipIdentifiersSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListOwnershipIdentifiersResponder handles the response to the ListOwnershipIdentifiers request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) ListOwnershipIdentifiersResponder(resp *http.Response) (result DomainOwnershipIdentifierCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListOwnershipIdentifiersNextResults retrieves the next set of results, if any.
+func (client DomainsClient) ListOwnershipIdentifiersNextResults(lastResults DomainOwnershipIdentifierCollection) (result DomainOwnershipIdentifierCollection, err error) {
+ req, err := lastResults.DomainOwnershipIdentifierCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.DomainsClient", "ListOwnershipIdentifiers", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListOwnershipIdentifiersSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.DomainsClient", "ListOwnershipIdentifiers", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListOwnershipIdentifiersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListOwnershipIdentifiers", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListRecommendations get domain name recommendations based on keywords.
+//
+// parameters is search parameters for domain name recommendations.
+func (client DomainsClient) ListRecommendations(parameters DomainRecommendationSearchParameters) (result NameIdentifierCollection, err error) {
+ req, err := client.ListRecommendationsPreparer(parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListRecommendations", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListRecommendationsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListRecommendations", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListRecommendationsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListRecommendations", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListRecommendationsPreparer prepares the ListRecommendations request.
+func (client DomainsClient) ListRecommendationsPreparer(parameters DomainRecommendationSearchParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/listDomainRecommendations", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListRecommendationsSender sends the ListRecommendations request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) ListRecommendationsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListRecommendationsResponder handles the response to the ListRecommendations request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) ListRecommendationsResponder(resp *http.Response) (result NameIdentifierCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListRecommendationsNextResults retrieves the next set of results, if any.
+func (client DomainsClient) ListRecommendationsNextResults(lastResults NameIdentifierCollection) (result NameIdentifierCollection, err error) {
+ req, err := lastResults.NameIdentifierCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.DomainsClient", "ListRecommendations", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListRecommendationsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.DomainsClient", "ListRecommendations", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListRecommendationsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "ListRecommendations", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// UpdateOwnershipIdentifier creates an ownership identifier for a domain or
+// updates identifier details for an existing identifer
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. domainName is name of domain. name is name of identifier.
+// domainOwnershipIdentifier is a JSON representation of the domain ownership
+// properties.
+func (client DomainsClient) UpdateOwnershipIdentifier(resourceGroupName string, domainName string, name string, domainOwnershipIdentifier DomainOwnershipIdentifier) (result DomainOwnershipIdentifier, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.DomainsClient", "UpdateOwnershipIdentifier")
+ }
+
+ req, err := client.UpdateOwnershipIdentifierPreparer(resourceGroupName, domainName, name, domainOwnershipIdentifier)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "UpdateOwnershipIdentifier", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateOwnershipIdentifierSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "UpdateOwnershipIdentifier", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateOwnershipIdentifierResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.DomainsClient", "UpdateOwnershipIdentifier", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdateOwnershipIdentifierPreparer prepares the UpdateOwnershipIdentifier request.
+func (client DomainsClient) UpdateOwnershipIdentifierPreparer(resourceGroupName string, domainName string, name string, domainOwnershipIdentifier DomainOwnershipIdentifier) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "domainName": autorest.Encode("path", domainName),
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DomainRegistration/domains/{domainName}/domainOwnershipIdentifiers/{name}", pathParameters),
+ autorest.WithJSON(domainOwnershipIdentifier),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// UpdateOwnershipIdentifierSender sends the UpdateOwnershipIdentifier request. The method will close the
+// http.Response Body if it receives an error.
+func (client DomainsClient) UpdateOwnershipIdentifierSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// UpdateOwnershipIdentifierResponder handles the response to the UpdateOwnershipIdentifier request. The method always
+// closes the http.Response Body.
+func (client DomainsClient) UpdateOwnershipIdentifierResponder(resp *http.Response) (result DomainOwnershipIdentifier, 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/Azure/azure-sdk-for-go/arm/web/models.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/models.go
new file mode 100755
index 000000000000..005ade8c658c
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/models.go
@@ -0,0 +1,3673 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/date"
+ "github.com/Azure/go-autorest/autorest/to"
+ "github.com/satori/uuid"
+ "io"
+ "net/http"
+)
+
+// AccessControlEntryAction enumerates the values for access control entry
+// action.
+type AccessControlEntryAction string
+
+const (
+ // Deny specifies the deny state for access control entry action.
+ Deny AccessControlEntryAction = "Deny"
+ // Permit specifies the permit state for access control entry action.
+ Permit AccessControlEntryAction = "Permit"
+)
+
+// AppServicePlanRestrictions enumerates the values for app service plan
+// restrictions.
+type AppServicePlanRestrictions string
+
+const (
+ // Basic specifies the basic state for app service plan restrictions.
+ Basic AppServicePlanRestrictions = "Basic"
+ // Free specifies the free state for app service plan restrictions.
+ Free AppServicePlanRestrictions = "Free"
+ // None specifies the none state for app service plan restrictions.
+ None AppServicePlanRestrictions = "None"
+ // Premium specifies the premium state for app service plan restrictions.
+ Premium AppServicePlanRestrictions = "Premium"
+ // Shared specifies the shared state for app service plan restrictions.
+ Shared AppServicePlanRestrictions = "Shared"
+ // Standard specifies the standard state for app service plan restrictions.
+ Standard AppServicePlanRestrictions = "Standard"
+)
+
+// AutoHealActionType enumerates the values for auto heal action type.
+type AutoHealActionType string
+
+const (
+ // CustomAction specifies the custom action state for auto heal action
+ // type.
+ CustomAction AutoHealActionType = "CustomAction"
+ // LogEvent specifies the log event state for auto heal action type.
+ LogEvent AutoHealActionType = "LogEvent"
+ // Recycle specifies the recycle state for auto heal action type.
+ Recycle AutoHealActionType = "Recycle"
+)
+
+// AzureResourceType enumerates the values for azure resource type.
+type AzureResourceType string
+
+const (
+ // TrafficManager specifies the traffic manager state for azure resource
+ // type.
+ TrafficManager AzureResourceType = "TrafficManager"
+ // Website specifies the website state for azure resource type.
+ Website AzureResourceType = "Website"
+)
+
+// BackupItemStatus enumerates the values for backup item status.
+type BackupItemStatus string
+
+const (
+ // Created specifies the created state for backup item status.
+ Created BackupItemStatus = "Created"
+ // Deleted specifies the deleted state for backup item status.
+ Deleted BackupItemStatus = "Deleted"
+ // DeleteFailed specifies the delete failed state for backup item status.
+ DeleteFailed BackupItemStatus = "DeleteFailed"
+ // DeleteInProgress specifies the delete in progress state for backup item
+ // status.
+ DeleteInProgress BackupItemStatus = "DeleteInProgress"
+ // Failed specifies the failed state for backup item status.
+ Failed BackupItemStatus = "Failed"
+ // InProgress specifies the in progress state for backup item status.
+ InProgress BackupItemStatus = "InProgress"
+ // PartiallySucceeded specifies the partially succeeded state for backup
+ // item status.
+ PartiallySucceeded BackupItemStatus = "PartiallySucceeded"
+ // Skipped specifies the skipped state for backup item status.
+ Skipped BackupItemStatus = "Skipped"
+ // Succeeded specifies the succeeded state for backup item status.
+ Succeeded BackupItemStatus = "Succeeded"
+ // TimedOut specifies the timed out state for backup item status.
+ TimedOut BackupItemStatus = "TimedOut"
+)
+
+// BackupRestoreOperationType enumerates the values for backup restore
+// operation type.
+type BackupRestoreOperationType string
+
+const (
+ // Clone specifies the clone state for backup restore operation type.
+ Clone BackupRestoreOperationType = "Clone"
+ // Default specifies the default state for backup restore operation type.
+ Default BackupRestoreOperationType = "Default"
+ // Relocation specifies the relocation state for backup restore operation
+ // type.
+ Relocation BackupRestoreOperationType = "Relocation"
+)
+
+// BuiltInAuthenticationProvider enumerates the values for built in
+// authentication provider.
+type BuiltInAuthenticationProvider string
+
+const (
+ // AzureActiveDirectory specifies the azure active directory state for
+ // built in authentication provider.
+ AzureActiveDirectory BuiltInAuthenticationProvider = "AzureActiveDirectory"
+ // Facebook specifies the facebook state for built in authentication
+ // provider.
+ Facebook BuiltInAuthenticationProvider = "Facebook"
+ // Google specifies the google state for built in authentication provider.
+ Google BuiltInAuthenticationProvider = "Google"
+ // MicrosoftAccount specifies the microsoft account state for built in
+ // authentication provider.
+ MicrosoftAccount BuiltInAuthenticationProvider = "MicrosoftAccount"
+ // Twitter specifies the twitter state for built in authentication
+ // provider.
+ Twitter BuiltInAuthenticationProvider = "Twitter"
+)
+
+// CertificateOrderActionType enumerates the values for certificate order
+// action type.
+type CertificateOrderActionType string
+
+const (
+ // CertificateExpirationWarning specifies the certificate expiration
+ // warning state for certificate order action type.
+ CertificateExpirationWarning CertificateOrderActionType = "CertificateExpirationWarning"
+ // CertificateExpired specifies the certificate expired state for
+ // certificate order action type.
+ CertificateExpired CertificateOrderActionType = "CertificateExpired"
+ // CertificateIssued specifies the certificate issued state for certificate
+ // order action type.
+ CertificateIssued CertificateOrderActionType = "CertificateIssued"
+ // CertificateOrderCanceled specifies the certificate order canceled state
+ // for certificate order action type.
+ CertificateOrderCanceled CertificateOrderActionType = "CertificateOrderCanceled"
+ // CertificateOrderCreated specifies the certificate order created state
+ // for certificate order action type.
+ CertificateOrderCreated CertificateOrderActionType = "CertificateOrderCreated"
+ // CertificateRevoked specifies the certificate revoked state for
+ // certificate order action type.
+ CertificateRevoked CertificateOrderActionType = "CertificateRevoked"
+ // DomainValidationComplete specifies the domain validation complete state
+ // for certificate order action type.
+ DomainValidationComplete CertificateOrderActionType = "DomainValidationComplete"
+ // FraudCleared specifies the fraud cleared state for certificate order
+ // action type.
+ FraudCleared CertificateOrderActionType = "FraudCleared"
+ // FraudDetected specifies the fraud detected state for certificate order
+ // action type.
+ FraudDetected CertificateOrderActionType = "FraudDetected"
+ // FraudDocumentationRequired specifies the fraud documentation required
+ // state for certificate order action type.
+ FraudDocumentationRequired CertificateOrderActionType = "FraudDocumentationRequired"
+ // OrgNameChange specifies the org name change state for certificate order
+ // action type.
+ OrgNameChange CertificateOrderActionType = "OrgNameChange"
+ // OrgValidationComplete specifies the org validation complete state for
+ // certificate order action type.
+ OrgValidationComplete CertificateOrderActionType = "OrgValidationComplete"
+ // SanDrop specifies the san drop state for certificate order action type.
+ SanDrop CertificateOrderActionType = "SanDrop"
+ // Unknown specifies the unknown state for certificate order action type.
+ Unknown CertificateOrderActionType = "Unknown"
+)
+
+// CertificateOrderStatus enumerates the values for certificate order status.
+type CertificateOrderStatus string
+
+const (
+ // Canceled specifies the canceled state for certificate order status.
+ Canceled CertificateOrderStatus = "Canceled"
+ // Denied specifies the denied state for certificate order status.
+ Denied CertificateOrderStatus = "Denied"
+ // Expired specifies the expired state for certificate order status.
+ Expired CertificateOrderStatus = "Expired"
+ // Issued specifies the issued state for certificate order status.
+ Issued CertificateOrderStatus = "Issued"
+ // NotSubmitted specifies the not submitted state for certificate order
+ // status.
+ NotSubmitted CertificateOrderStatus = "NotSubmitted"
+ // Pendingissuance specifies the pendingissuance state for certificate
+ // order status.
+ Pendingissuance CertificateOrderStatus = "Pendingissuance"
+ // PendingRekey specifies the pending rekey state for certificate order
+ // status.
+ PendingRekey CertificateOrderStatus = "PendingRekey"
+ // Pendingrevocation specifies the pendingrevocation state for certificate
+ // order status.
+ Pendingrevocation CertificateOrderStatus = "Pendingrevocation"
+ // Revoked specifies the revoked state for certificate order status.
+ Revoked CertificateOrderStatus = "Revoked"
+ // Unused specifies the unused state for certificate order status.
+ Unused CertificateOrderStatus = "Unused"
+)
+
+// CertificateProductType enumerates the values for certificate product type.
+type CertificateProductType string
+
+const (
+ // StandardDomainValidatedSsl specifies the standard domain validated ssl
+ // state for certificate product type.
+ StandardDomainValidatedSsl CertificateProductType = "StandardDomainValidatedSsl"
+ // StandardDomainValidatedWildCardSsl specifies the standard domain
+ // validated wild card ssl state for certificate product type.
+ StandardDomainValidatedWildCardSsl CertificateProductType = "StandardDomainValidatedWildCardSsl"
+)
+
+// Channels enumerates the values for channels.
+type Channels string
+
+const (
+ // All specifies the all state for channels.
+ All Channels = "All"
+ // API specifies the api state for channels.
+ API Channels = "Api"
+ // Email specifies the email state for channels.
+ Email Channels = "Email"
+ // Notification specifies the notification state for channels.
+ Notification Channels = "Notification"
+ // Webhook specifies the webhook state for channels.
+ Webhook Channels = "Webhook"
+)
+
+// CheckNameResourceTypes enumerates the values for check name resource types.
+type CheckNameResourceTypes string
+
+const (
+ // CheckNameResourceTypesHostingEnvironment specifies the check name
+ // resource types hosting environment state for check name resource types.
+ CheckNameResourceTypesHostingEnvironment CheckNameResourceTypes = "HostingEnvironment"
+ // CheckNameResourceTypesSite specifies the check name resource types site
+ // state for check name resource types.
+ CheckNameResourceTypesSite CheckNameResourceTypes = "Site"
+ // CheckNameResourceTypesSlot specifies the check name resource types slot
+ // state for check name resource types.
+ CheckNameResourceTypesSlot CheckNameResourceTypes = "Slot"
+)
+
+// CloneAbilityResult enumerates the values for clone ability result.
+type CloneAbilityResult string
+
+const (
+ // Cloneable specifies the cloneable state for clone ability result.
+ Cloneable CloneAbilityResult = "Cloneable"
+ // NotCloneable specifies the not cloneable state for clone ability result.
+ NotCloneable CloneAbilityResult = "NotCloneable"
+ // PartiallyCloneable specifies the partially cloneable state for clone
+ // ability result.
+ PartiallyCloneable CloneAbilityResult = "PartiallyCloneable"
+)
+
+// ComputeModeOptions enumerates the values for compute mode options.
+type ComputeModeOptions string
+
+const (
+ // ComputeModeOptionsDedicated specifies the compute mode options dedicated
+ // state for compute mode options.
+ ComputeModeOptionsDedicated ComputeModeOptions = "Dedicated"
+ // ComputeModeOptionsDynamic specifies the compute mode options dynamic
+ // state for compute mode options.
+ ComputeModeOptionsDynamic ComputeModeOptions = "Dynamic"
+ // ComputeModeOptionsShared specifies the compute mode options shared state
+ // for compute mode options.
+ ComputeModeOptionsShared ComputeModeOptions = "Shared"
+)
+
+// ConnectionStringType enumerates the values for connection string type.
+type ConnectionStringType string
+
+const (
+ // APIHub specifies the api hub state for connection string type.
+ APIHub ConnectionStringType = "ApiHub"
+ // Custom specifies the custom state for connection string type.
+ Custom ConnectionStringType = "Custom"
+ // DocDb specifies the doc db state for connection string type.
+ DocDb ConnectionStringType = "DocDb"
+ // EventHub specifies the event hub state for connection string type.
+ EventHub ConnectionStringType = "EventHub"
+ // MySQL specifies the my sql state for connection string type.
+ MySQL ConnectionStringType = "MySql"
+ // NotificationHub specifies the notification hub state for connection
+ // string type.
+ NotificationHub ConnectionStringType = "NotificationHub"
+ // PostgreSQL specifies the postgre sql state for connection string type.
+ PostgreSQL ConnectionStringType = "PostgreSQL"
+ // RedisCache specifies the redis cache state for connection string type.
+ RedisCache ConnectionStringType = "RedisCache"
+ // ServiceBus specifies the service bus state for connection string type.
+ ServiceBus ConnectionStringType = "ServiceBus"
+ // SQLAzure specifies the sql azure state for connection string type.
+ SQLAzure ConnectionStringType = "SQLAzure"
+ // SQLServer specifies the sql server state for connection string type.
+ SQLServer ConnectionStringType = "SQLServer"
+)
+
+// CustomHostNameDNSRecordType enumerates the values for custom host name dns
+// record type.
+type CustomHostNameDNSRecordType string
+
+const (
+ // A specifies the a state for custom host name dns record type.
+ A CustomHostNameDNSRecordType = "A"
+ // CName specifies the c name state for custom host name dns record type.
+ CName CustomHostNameDNSRecordType = "CName"
+)
+
+// DatabaseType enumerates the values for database type.
+type DatabaseType string
+
+const (
+ // DatabaseTypeLocalMySQL specifies the database type local my sql state
+ // for database type.
+ DatabaseTypeLocalMySQL DatabaseType = "LocalMySql"
+ // DatabaseTypeMySQL specifies the database type my sql state for database
+ // type.
+ DatabaseTypeMySQL DatabaseType = "MySql"
+ // DatabaseTypePostgreSQL specifies the database type postgre sql state for
+ // database type.
+ DatabaseTypePostgreSQL DatabaseType = "PostgreSql"
+ // DatabaseTypeSQLAzure specifies the database type sql azure state for
+ // database type.
+ DatabaseTypeSQLAzure DatabaseType = "SqlAzure"
+)
+
+// DNSType enumerates the values for dns type.
+type DNSType string
+
+const (
+ // AzureDNS specifies the azure dns state for dns type.
+ AzureDNS DNSType = "AzureDns"
+ // DefaultDomainRegistrarDNS specifies the default domain registrar dns
+ // state for dns type.
+ DefaultDomainRegistrarDNS DNSType = "DefaultDomainRegistrarDns"
+)
+
+// DNSVerificationTestResult enumerates the values for dns verification test
+// result.
+type DNSVerificationTestResult string
+
+const (
+ // DNSVerificationTestResultFailed specifies the dns verification test
+ // result failed state for dns verification test result.
+ DNSVerificationTestResultFailed DNSVerificationTestResult = "Failed"
+ // DNSVerificationTestResultPassed specifies the dns verification test
+ // result passed state for dns verification test result.
+ DNSVerificationTestResultPassed DNSVerificationTestResult = "Passed"
+ // DNSVerificationTestResultSkipped specifies the dns verification test
+ // result skipped state for dns verification test result.
+ DNSVerificationTestResultSkipped DNSVerificationTestResult = "Skipped"
+)
+
+// DomainStatus enumerates the values for domain status.
+type DomainStatus string
+
+const (
+ // DomainStatusActive specifies the domain status active state for domain
+ // status.
+ DomainStatusActive DomainStatus = "Active"
+ // DomainStatusAwaiting specifies the domain status awaiting state for
+ // domain status.
+ DomainStatusAwaiting DomainStatus = "Awaiting"
+ // DomainStatusCancelled specifies the domain status cancelled state for
+ // domain status.
+ DomainStatusCancelled DomainStatus = "Cancelled"
+ // DomainStatusConfiscated specifies the domain status confiscated state
+ // for domain status.
+ DomainStatusConfiscated DomainStatus = "Confiscated"
+ // DomainStatusDisabled specifies the domain status disabled state for
+ // domain status.
+ DomainStatusDisabled DomainStatus = "Disabled"
+ // DomainStatusExcluded specifies the domain status excluded state for
+ // domain status.
+ DomainStatusExcluded DomainStatus = "Excluded"
+ // DomainStatusExpired specifies the domain status expired state for domain
+ // status.
+ DomainStatusExpired DomainStatus = "Expired"
+ // DomainStatusFailed specifies the domain status failed state for domain
+ // status.
+ DomainStatusFailed DomainStatus = "Failed"
+ // DomainStatusHeld specifies the domain status held state for domain
+ // status.
+ DomainStatusHeld DomainStatus = "Held"
+ // DomainStatusJSONConverterFailed specifies the domain status json
+ // converter failed state for domain status.
+ DomainStatusJSONConverterFailed DomainStatus = "JsonConverterFailed"
+ // DomainStatusLocked specifies the domain status locked state for domain
+ // status.
+ DomainStatusLocked DomainStatus = "Locked"
+ // DomainStatusParked specifies the domain status parked state for domain
+ // status.
+ DomainStatusParked DomainStatus = "Parked"
+ // DomainStatusPending specifies the domain status pending state for domain
+ // status.
+ DomainStatusPending DomainStatus = "Pending"
+ // DomainStatusReserved specifies the domain status reserved state for
+ // domain status.
+ DomainStatusReserved DomainStatus = "Reserved"
+ // DomainStatusReverted specifies the domain status reverted state for
+ // domain status.
+ DomainStatusReverted DomainStatus = "Reverted"
+ // DomainStatusSuspended specifies the domain status suspended state for
+ // domain status.
+ DomainStatusSuspended DomainStatus = "Suspended"
+ // DomainStatusTransferred specifies the domain status transferred state
+ // for domain status.
+ DomainStatusTransferred DomainStatus = "Transferred"
+ // DomainStatusUnknown specifies the domain status unknown state for domain
+ // status.
+ DomainStatusUnknown DomainStatus = "Unknown"
+ // DomainStatusUnlocked specifies the domain status unlocked state for
+ // domain status.
+ DomainStatusUnlocked DomainStatus = "Unlocked"
+ // DomainStatusUnparked specifies the domain status unparked state for
+ // domain status.
+ DomainStatusUnparked DomainStatus = "Unparked"
+ // DomainStatusUpdated specifies the domain status updated state for domain
+ // status.
+ DomainStatusUpdated DomainStatus = "Updated"
+)
+
+// DomainType enumerates the values for domain type.
+type DomainType string
+
+const (
+ // Regular specifies the regular state for domain type.
+ Regular DomainType = "Regular"
+ // SoftDeleted specifies the soft deleted state for domain type.
+ SoftDeleted DomainType = "SoftDeleted"
+)
+
+// FrequencyUnit enumerates the values for frequency unit.
+type FrequencyUnit string
+
+const (
+ // Day specifies the day state for frequency unit.
+ Day FrequencyUnit = "Day"
+ // Hour specifies the hour state for frequency unit.
+ Hour FrequencyUnit = "Hour"
+)
+
+// HostingEnvironmentStatus enumerates the values for hosting environment
+// status.
+type HostingEnvironmentStatus string
+
+const (
+ // Deleting specifies the deleting state for hosting environment status.
+ Deleting HostingEnvironmentStatus = "Deleting"
+ // Preparing specifies the preparing state for hosting environment status.
+ Preparing HostingEnvironmentStatus = "Preparing"
+ // Ready specifies the ready state for hosting environment status.
+ Ready HostingEnvironmentStatus = "Ready"
+ // Scaling specifies the scaling state for hosting environment status.
+ Scaling HostingEnvironmentStatus = "Scaling"
+)
+
+// HostNameType enumerates the values for host name type.
+type HostNameType string
+
+const (
+ // Managed specifies the managed state for host name type.
+ Managed HostNameType = "Managed"
+ // Verified specifies the verified state for host name type.
+ Verified HostNameType = "Verified"
+)
+
+// HostType enumerates the values for host type.
+type HostType string
+
+const (
+ // HostTypeRepository specifies the host type repository state for host
+ // type.
+ HostTypeRepository HostType = "Repository"
+ // HostTypeStandard specifies the host type standard state for host type.
+ HostTypeStandard HostType = "Standard"
+)
+
+// InAvailabilityReasonType enumerates the values for in availability reason
+// type.
+type InAvailabilityReasonType string
+
+const (
+ // AlreadyExists specifies the already exists state for in availability
+ // reason type.
+ AlreadyExists InAvailabilityReasonType = "AlreadyExists"
+ // Invalid specifies the invalid state for in availability reason type.
+ Invalid InAvailabilityReasonType = "Invalid"
+)
+
+// InternalLoadBalancingMode enumerates the values for internal load balancing
+// mode.
+type InternalLoadBalancingMode string
+
+const (
+ // InternalLoadBalancingModeNone specifies the internal load balancing mode
+ // none state for internal load balancing mode.
+ InternalLoadBalancingModeNone InternalLoadBalancingMode = "None"
+ // InternalLoadBalancingModePublishing specifies the internal load
+ // balancing mode publishing state for internal load balancing mode.
+ InternalLoadBalancingModePublishing InternalLoadBalancingMode = "Publishing"
+ // InternalLoadBalancingModeWeb specifies the internal load balancing mode
+ // web state for internal load balancing mode.
+ InternalLoadBalancingModeWeb InternalLoadBalancingMode = "Web"
+)
+
+// KeyVaultSecretStatus enumerates the values for key vault secret status.
+type KeyVaultSecretStatus string
+
+const (
+ // KeyVaultSecretStatusAzureServiceUnauthorizedToAccessKeyVault specifies
+ // the key vault secret status azure service unauthorized to access key
+ // vault state for key vault secret status.
+ KeyVaultSecretStatusAzureServiceUnauthorizedToAccessKeyVault KeyVaultSecretStatus = "AzureServiceUnauthorizedToAccessKeyVault"
+ // KeyVaultSecretStatusCertificateOrderFailed specifies the key vault
+ // secret status certificate order failed state for key vault secret
+ // status.
+ KeyVaultSecretStatusCertificateOrderFailed KeyVaultSecretStatus = "CertificateOrderFailed"
+ // KeyVaultSecretStatusExternalPrivateKey specifies the key vault secret
+ // status external private key state for key vault secret status.
+ KeyVaultSecretStatusExternalPrivateKey KeyVaultSecretStatus = "ExternalPrivateKey"
+ // KeyVaultSecretStatusInitialized specifies the key vault secret status
+ // initialized state for key vault secret status.
+ KeyVaultSecretStatusInitialized KeyVaultSecretStatus = "Initialized"
+ // KeyVaultSecretStatusKeyVaultDoesNotExist specifies the key vault secret
+ // status key vault does not exist state for key vault secret status.
+ KeyVaultSecretStatusKeyVaultDoesNotExist KeyVaultSecretStatus = "KeyVaultDoesNotExist"
+ // KeyVaultSecretStatusKeyVaultSecretDoesNotExist specifies the key vault
+ // secret status key vault secret does not exist state for key vault secret
+ // status.
+ KeyVaultSecretStatusKeyVaultSecretDoesNotExist KeyVaultSecretStatus = "KeyVaultSecretDoesNotExist"
+ // KeyVaultSecretStatusOperationNotPermittedOnKeyVault specifies the key
+ // vault secret status operation not permitted on key vault state for key
+ // vault secret status.
+ KeyVaultSecretStatusOperationNotPermittedOnKeyVault KeyVaultSecretStatus = "OperationNotPermittedOnKeyVault"
+ // KeyVaultSecretStatusSucceeded specifies the key vault secret status
+ // succeeded state for key vault secret status.
+ KeyVaultSecretStatusSucceeded KeyVaultSecretStatus = "Succeeded"
+ // KeyVaultSecretStatusUnknown specifies the key vault secret status
+ // unknown state for key vault secret status.
+ KeyVaultSecretStatusUnknown KeyVaultSecretStatus = "Unknown"
+ // KeyVaultSecretStatusUnknownError specifies the key vault secret status
+ // unknown error state for key vault secret status.
+ KeyVaultSecretStatusUnknownError KeyVaultSecretStatus = "UnknownError"
+ // KeyVaultSecretStatusWaitingOnCertificateOrder specifies the key vault
+ // secret status waiting on certificate order state for key vault secret
+ // status.
+ KeyVaultSecretStatusWaitingOnCertificateOrder KeyVaultSecretStatus = "WaitingOnCertificateOrder"
+)
+
+// LogLevel enumerates the values for log level.
+type LogLevel string
+
+const (
+ // Error specifies the error state for log level.
+ Error LogLevel = "Error"
+ // Information specifies the information state for log level.
+ Information LogLevel = "Information"
+ // Off specifies the off state for log level.
+ Off LogLevel = "Off"
+ // Verbose specifies the verbose state for log level.
+ Verbose LogLevel = "Verbose"
+ // Warning specifies the warning state for log level.
+ Warning LogLevel = "Warning"
+)
+
+// ManagedPipelineMode enumerates the values for managed pipeline mode.
+type ManagedPipelineMode string
+
+const (
+ // Classic specifies the classic state for managed pipeline mode.
+ Classic ManagedPipelineMode = "Classic"
+ // Integrated specifies the integrated state for managed pipeline mode.
+ Integrated ManagedPipelineMode = "Integrated"
+)
+
+// NotificationLevel enumerates the values for notification level.
+type NotificationLevel string
+
+const (
+ // NotificationLevelCritical specifies the notification level critical
+ // state for notification level.
+ NotificationLevelCritical NotificationLevel = "Critical"
+ // NotificationLevelInformation specifies the notification level
+ // information state for notification level.
+ NotificationLevelInformation NotificationLevel = "Information"
+ // NotificationLevelNonUrgentSuggestion specifies the notification level
+ // non urgent suggestion state for notification level.
+ NotificationLevelNonUrgentSuggestion NotificationLevel = "NonUrgentSuggestion"
+ // NotificationLevelWarning specifies the notification level warning state
+ // for notification level.
+ NotificationLevelWarning NotificationLevel = "Warning"
+)
+
+// OperationStatus enumerates the values for operation status.
+type OperationStatus string
+
+const (
+ // OperationStatusCreated specifies the operation status created state for
+ // operation status.
+ OperationStatusCreated OperationStatus = "Created"
+ // OperationStatusFailed specifies the operation status failed state for
+ // operation status.
+ OperationStatusFailed OperationStatus = "Failed"
+ // OperationStatusInProgress specifies the operation status in progress
+ // state for operation status.
+ OperationStatusInProgress OperationStatus = "InProgress"
+ // OperationStatusSucceeded specifies the operation status succeeded state
+ // for operation status.
+ OperationStatusSucceeded OperationStatus = "Succeeded"
+ // OperationStatusTimedOut specifies the operation status timed out state
+ // for operation status.
+ OperationStatusTimedOut OperationStatus = "TimedOut"
+)
+
+// ProvisioningState enumerates the values for provisioning state.
+type ProvisioningState string
+
+const (
+ // ProvisioningStateCanceled specifies the provisioning state canceled
+ // state for provisioning state.
+ ProvisioningStateCanceled ProvisioningState = "Canceled"
+ // ProvisioningStateDeleting specifies the provisioning state deleting
+ // state for provisioning state.
+ ProvisioningStateDeleting ProvisioningState = "Deleting"
+ // ProvisioningStateFailed specifies the provisioning state failed state
+ // for provisioning state.
+ ProvisioningStateFailed ProvisioningState = "Failed"
+ // ProvisioningStateInProgress specifies the provisioning state in progress
+ // state for provisioning state.
+ ProvisioningStateInProgress ProvisioningState = "InProgress"
+ // ProvisioningStateSucceeded specifies the provisioning state succeeded
+ // state for provisioning state.
+ ProvisioningStateSucceeded ProvisioningState = "Succeeded"
+)
+
+// PublishingProfileFormat enumerates the values for publishing profile format.
+type PublishingProfileFormat string
+
+const (
+ // FileZilla3 specifies the file zilla 3 state for publishing profile
+ // format.
+ FileZilla3 PublishingProfileFormat = "FileZilla3"
+ // Ftp specifies the ftp state for publishing profile format.
+ Ftp PublishingProfileFormat = "Ftp"
+ // WebDeploy specifies the web deploy state for publishing profile format.
+ WebDeploy PublishingProfileFormat = "WebDeploy"
+)
+
+// ResourceScopeType enumerates the values for resource scope type.
+type ResourceScopeType string
+
+const (
+ // ServerFarm specifies the server farm state for resource scope type.
+ ServerFarm ResourceScopeType = "ServerFarm"
+ // Subscription specifies the subscription state for resource scope type.
+ Subscription ResourceScopeType = "Subscription"
+ // WebSite specifies the web site state for resource scope type.
+ WebSite ResourceScopeType = "WebSite"
+)
+
+// RouteType enumerates the values for route type.
+type RouteType string
+
+const (
+ // DEFAULT specifies the default state for route type.
+ DEFAULT RouteType = "DEFAULT"
+ // INHERITED specifies the inherited state for route type.
+ INHERITED RouteType = "INHERITED"
+ // STATIC specifies the static state for route type.
+ STATIC RouteType = "STATIC"
+)
+
+// ScmType enumerates the values for scm type.
+type ScmType string
+
+const (
+ // ScmTypeBitbucketGit specifies the scm type bitbucket git state for scm
+ // type.
+ ScmTypeBitbucketGit ScmType = "BitbucketGit"
+ // ScmTypeBitbucketHg specifies the scm type bitbucket hg state for scm
+ // type.
+ ScmTypeBitbucketHg ScmType = "BitbucketHg"
+ // ScmTypeCodePlexGit specifies the scm type code plex git state for scm
+ // type.
+ ScmTypeCodePlexGit ScmType = "CodePlexGit"
+ // ScmTypeCodePlexHg specifies the scm type code plex hg state for scm
+ // type.
+ ScmTypeCodePlexHg ScmType = "CodePlexHg"
+ // ScmTypeDropbox specifies the scm type dropbox state for scm type.
+ ScmTypeDropbox ScmType = "Dropbox"
+ // ScmTypeExternalGit specifies the scm type external git state for scm
+ // type.
+ ScmTypeExternalGit ScmType = "ExternalGit"
+ // ScmTypeExternalHg specifies the scm type external hg state for scm type.
+ ScmTypeExternalHg ScmType = "ExternalHg"
+ // ScmTypeGitHub specifies the scm type git hub state for scm type.
+ ScmTypeGitHub ScmType = "GitHub"
+ // ScmTypeLocalGit specifies the scm type local git state for scm type.
+ ScmTypeLocalGit ScmType = "LocalGit"
+ // ScmTypeNone specifies the scm type none state for scm type.
+ ScmTypeNone ScmType = "None"
+ // ScmTypeOneDrive specifies the scm type one drive state for scm type.
+ ScmTypeOneDrive ScmType = "OneDrive"
+ // ScmTypeTfs specifies the scm type tfs state for scm type.
+ ScmTypeTfs ScmType = "Tfs"
+ // ScmTypeVSO specifies the scm type vso state for scm type.
+ ScmTypeVSO ScmType = "VSO"
+)
+
+// SiteAvailabilityState enumerates the values for site availability state.
+type SiteAvailabilityState string
+
+const (
+ // DisasterRecoveryMode specifies the disaster recovery mode state for site
+ // availability state.
+ DisasterRecoveryMode SiteAvailabilityState = "DisasterRecoveryMode"
+ // Limited specifies the limited state for site availability state.
+ Limited SiteAvailabilityState = "Limited"
+ // Normal specifies the normal state for site availability state.
+ Normal SiteAvailabilityState = "Normal"
+)
+
+// SiteLoadBalancing enumerates the values for site load balancing.
+type SiteLoadBalancing string
+
+const (
+ // LeastRequests specifies the least requests state for site load
+ // balancing.
+ LeastRequests SiteLoadBalancing = "LeastRequests"
+ // LeastResponseTime specifies the least response time state for site load
+ // balancing.
+ LeastResponseTime SiteLoadBalancing = "LeastResponseTime"
+ // RequestHash specifies the request hash state for site load balancing.
+ RequestHash SiteLoadBalancing = "RequestHash"
+ // WeightedRoundRobin specifies the weighted round robin state for site
+ // load balancing.
+ WeightedRoundRobin SiteLoadBalancing = "WeightedRoundRobin"
+ // WeightedTotalTraffic specifies the weighted total traffic state for site
+ // load balancing.
+ WeightedTotalTraffic SiteLoadBalancing = "WeightedTotalTraffic"
+)
+
+// SkuName enumerates the values for sku name.
+type SkuName string
+
+const (
+ // SkuNameBasic specifies the sku name basic state for sku name.
+ SkuNameBasic SkuName = "Basic"
+ // SkuNameDynamic specifies the sku name dynamic state for sku name.
+ SkuNameDynamic SkuName = "Dynamic"
+ // SkuNameFree specifies the sku name free state for sku name.
+ SkuNameFree SkuName = "Free"
+ // SkuNameIsolated specifies the sku name isolated state for sku name.
+ SkuNameIsolated SkuName = "Isolated"
+ // SkuNamePremium specifies the sku name premium state for sku name.
+ SkuNamePremium SkuName = "Premium"
+ // SkuNameShared specifies the sku name shared state for sku name.
+ SkuNameShared SkuName = "Shared"
+ // SkuNameStandard specifies the sku name standard state for sku name.
+ SkuNameStandard SkuName = "Standard"
+)
+
+// SslState enumerates the values for ssl state.
+type SslState string
+
+const (
+ // Disabled specifies the disabled state for ssl state.
+ Disabled SslState = "Disabled"
+ // IPBasedEnabled specifies the ip based enabled state for ssl state.
+ IPBasedEnabled SslState = "IpBasedEnabled"
+ // SniEnabled specifies the sni enabled state for ssl state.
+ SniEnabled SslState = "SniEnabled"
+)
+
+// StatusOptions enumerates the values for status options.
+type StatusOptions string
+
+const (
+ // StatusOptionsPending specifies the status options pending state for
+ // status options.
+ StatusOptionsPending StatusOptions = "Pending"
+ // StatusOptionsReady specifies the status options ready state for status
+ // options.
+ StatusOptionsReady StatusOptions = "Ready"
+)
+
+// UnauthenticatedClientAction enumerates the values for unauthenticated client
+// action.
+type UnauthenticatedClientAction string
+
+const (
+ // AllowAnonymous specifies the allow anonymous state for unauthenticated
+ // client action.
+ AllowAnonymous UnauthenticatedClientAction = "AllowAnonymous"
+ // RedirectToLoginPage specifies the redirect to login page state for
+ // unauthenticated client action.
+ RedirectToLoginPage UnauthenticatedClientAction = "RedirectToLoginPage"
+)
+
+// UsageState enumerates the values for usage state.
+type UsageState string
+
+const (
+ // UsageStateExceeded specifies the usage state exceeded state for usage
+ // state.
+ UsageStateExceeded UsageState = "Exceeded"
+ // UsageStateNormal specifies the usage state normal state for usage state.
+ UsageStateNormal UsageState = "Normal"
+)
+
+// ValidateResourceTypes enumerates the values for validate resource types.
+type ValidateResourceTypes string
+
+const (
+ // ValidateResourceTypesServerFarm specifies the validate resource types
+ // server farm state for validate resource types.
+ ValidateResourceTypesServerFarm ValidateResourceTypes = "ServerFarm"
+ // ValidateResourceTypesSite specifies the validate resource types site
+ // state for validate resource types.
+ ValidateResourceTypesSite ValidateResourceTypes = "Site"
+)
+
+// WorkerSizeOptions enumerates the values for worker size options.
+type WorkerSizeOptions string
+
+const (
+ // WorkerSizeOptionsDefault specifies the worker size options default state
+ // for worker size options.
+ WorkerSizeOptionsDefault WorkerSizeOptions = "Default"
+ // WorkerSizeOptionsLarge specifies the worker size options large state for
+ // worker size options.
+ WorkerSizeOptionsLarge WorkerSizeOptions = "Large"
+ // WorkerSizeOptionsMedium specifies the worker size options medium state
+ // for worker size options.
+ WorkerSizeOptionsMedium WorkerSizeOptions = "Medium"
+ // WorkerSizeOptionsSmall specifies the worker size options small state for
+ // worker size options.
+ WorkerSizeOptionsSmall WorkerSizeOptions = "Small"
+)
+
+// Address is address information for domain registration.
+type Address struct {
+ Address1 *string `json:"address1,omitempty"`
+ Address2 *string `json:"address2,omitempty"`
+ City *string `json:"city,omitempty"`
+ Country *string `json:"country,omitempty"`
+ PostalCode *string `json:"postalCode,omitempty"`
+ State *string `json:"state,omitempty"`
+}
+
+// AddressResponse is describes main public IP address and any extra virtual
+// IPs.
+type AddressResponse struct {
+ autorest.Response `json:"-"`
+ ServiceIPAddress *string `json:"serviceIpAddress,omitempty"`
+ InternalIPAddress *string `json:"internalIpAddress,omitempty"`
+ OutboundIPAddresses *[]string `json:"outboundIpAddresses,omitempty"`
+ VipMappings *[]VirtualIPMapping `json:"vipMappings,omitempty"`
+}
+
+// APIDefinitionInfo is information about the formal API definition for the
+// app.
+type APIDefinitionInfo struct {
+ URL *string `json:"url,omitempty"`
+}
+
+// AppCollection is collection of App Service apps.
+type AppCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]Site `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AppCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client AppCollection) AppCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// AppInstanceCollection is collection of app instances.
+type AppInstanceCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]SiteInstance `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AppInstanceCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client AppInstanceCollection) AppInstanceCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// ApplicationLogsConfig is application logs configuration.
+type ApplicationLogsConfig struct {
+ FileSystem *FileSystemApplicationLogsConfig `json:"fileSystem,omitempty"`
+ AzureTableStorage *AzureTableStorageApplicationLogsConfig `json:"azureTableStorage,omitempty"`
+ AzureBlobStorage *AzureBlobStorageApplicationLogsConfig `json:"azureBlobStorage,omitempty"`
+}
+
+// AppServiceCertificate is key Vault container for a certificate that is
+// purchased through Azure.
+type AppServiceCertificate struct {
+ KeyVaultID *string `json:"keyVaultId,omitempty"`
+ KeyVaultSecretName *string `json:"keyVaultSecretName,omitempty"`
+ ProvisioningState KeyVaultSecretStatus `json:"provisioningState,omitempty"`
+}
+
+// AppServiceCertificateCollection is collection of certitificateorder
+// certificates.
+type AppServiceCertificateCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]AppServiceCertificateResource `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AppServiceCertificateCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client AppServiceCertificateCollection) AppServiceCertificateCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// AppServiceCertificateOrder is sSL certificate purchase order.
+type AppServiceCertificateOrder struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *AppServiceCertificateOrderProperties `json:"properties,omitempty"`
+}
+
+// AppServiceCertificateOrderProperties is appServiceCertificateOrder resource
+// specific properties
+type AppServiceCertificateOrderProperties struct {
+ Certificates *map[string]*AppServiceCertificate `json:"certificates,omitempty"`
+ DistinguishedName *string `json:"distinguishedName,omitempty"`
+ DomainVerificationToken *string `json:"domainVerificationToken,omitempty"`
+ ValidityInYears *int32 `json:"validityInYears,omitempty"`
+ KeySize *int32 `json:"keySize,omitempty"`
+ ProductType CertificateProductType `json:"productType,omitempty"`
+ AutoRenew *bool `json:"autoRenew,omitempty"`
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+ Status CertificateOrderStatus `json:"status,omitempty"`
+ SignedCertificate *CertificateDetails `json:"signedCertificate,omitempty"`
+ Csr *string `json:"csr,omitempty"`
+ Intermediate *CertificateDetails `json:"intermediate,omitempty"`
+ Root *CertificateDetails `json:"root,omitempty"`
+ SerialNumber *string `json:"serialNumber,omitempty"`
+ LastCertificateIssuanceTime *date.Time `json:"lastCertificateIssuanceTime,omitempty"`
+ ExpirationTime *date.Time `json:"expirationTime,omitempty"`
+ IsPrivateKeyExternal *bool `json:"isPrivateKeyExternal,omitempty"`
+ AppServiceCertificateNotRenewableReasons *[]string `json:"appServiceCertificateNotRenewableReasons,omitempty"`
+ NextAutoRenewalTimeStamp *date.Time `json:"nextAutoRenewalTimeStamp,omitempty"`
+}
+
+// AppServiceCertificateOrderCollection is collection of certitificate orders.
+type AppServiceCertificateOrderCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]AppServiceCertificateOrder `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AppServiceCertificateOrderCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client AppServiceCertificateOrderCollection) AppServiceCertificateOrderCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// AppServiceCertificateResource is key Vault container ARM resource for a
+// certificate that is purchased through Azure.
+type AppServiceCertificateResource struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *AppServiceCertificate `json:"properties,omitempty"`
+}
+
+// AppServiceEnvironment is description of an App Service Environment.
+type AppServiceEnvironment struct {
+ Name *string `json:"name,omitempty"`
+ Location *string `json:"location,omitempty"`
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+ Status HostingEnvironmentStatus `json:"status,omitempty"`
+ VnetName *string `json:"vnetName,omitempty"`
+ VnetResourceGroupName *string `json:"vnetResourceGroupName,omitempty"`
+ VnetSubnetName *string `json:"vnetSubnetName,omitempty"`
+ VirtualNetwork *VirtualNetworkProfile `json:"virtualNetwork,omitempty"`
+ InternalLoadBalancingMode InternalLoadBalancingMode `json:"internalLoadBalancingMode,omitempty"`
+ MultiSize *string `json:"multiSize,omitempty"`
+ MultiRoleCount *int32 `json:"multiRoleCount,omitempty"`
+ WorkerPools *[]WorkerPool `json:"workerPools,omitempty"`
+ IpsslAddressCount *int32 `json:"ipsslAddressCount,omitempty"`
+ DatabaseEdition *string `json:"databaseEdition,omitempty"`
+ DatabaseServiceObjective *string `json:"databaseServiceObjective,omitempty"`
+ UpgradeDomains *int32 `json:"upgradeDomains,omitempty"`
+ SubscriptionID *string `json:"subscriptionId,omitempty"`
+ DNSSuffix *string `json:"dnsSuffix,omitempty"`
+ LastAction *string `json:"lastAction,omitempty"`
+ LastActionResult *string `json:"lastActionResult,omitempty"`
+ AllowedMultiSizes *string `json:"allowedMultiSizes,omitempty"`
+ AllowedWorkerSizes *string `json:"allowedWorkerSizes,omitempty"`
+ MaximumNumberOfMachines *int32 `json:"maximumNumberOfMachines,omitempty"`
+ VipMappings *[]VirtualIPMapping `json:"vipMappings,omitempty"`
+ EnvironmentCapacities *[]StampCapacity `json:"environmentCapacities,omitempty"`
+ NetworkAccessControlList *[]NetworkAccessControlEntry `json:"networkAccessControlList,omitempty"`
+ EnvironmentIsHealthy *bool `json:"environmentIsHealthy,omitempty"`
+ EnvironmentStatus *string `json:"environmentStatus,omitempty"`
+ ResourceGroup *string `json:"resourceGroup,omitempty"`
+ FrontEndScaleFactor *int32 `json:"frontEndScaleFactor,omitempty"`
+ DefaultFrontEndScaleFactor *int32 `json:"defaultFrontEndScaleFactor,omitempty"`
+ APIManagementAccountID *string `json:"apiManagementAccountId,omitempty"`
+ Suspended *bool `json:"suspended,omitempty"`
+ DynamicCacheEnabled *bool `json:"dynamicCacheEnabled,omitempty"`
+ ClusterSettings *[]NameValuePair `json:"clusterSettings,omitempty"`
+}
+
+// AppServiceEnvironmentCollection is collection of App Service Environments.
+type AppServiceEnvironmentCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]AppServiceEnvironment `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AppServiceEnvironmentCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client AppServiceEnvironmentCollection) AppServiceEnvironmentCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// AppServiceEnvironmentResource is app Service Environment ARM resource.
+type AppServiceEnvironmentResource struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *AppServiceEnvironment `json:"properties,omitempty"`
+}
+
+// AppServicePlan is app Service plan.
+type AppServicePlan struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *AppServicePlanProperties `json:"properties,omitempty"`
+ Sku *SkuDescription `json:"sku,omitempty"`
+}
+
+// AppServicePlanProperties is appServicePlan resource specific properties
+type AppServicePlanProperties struct {
+ Name *string `json:"name,omitempty"`
+ WorkerTierName *string `json:"workerTierName,omitempty"`
+ Status StatusOptions `json:"status,omitempty"`
+ Subscription *string `json:"subscription,omitempty"`
+ AdminSiteName *string `json:"adminSiteName,omitempty"`
+ HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"`
+ MaximumNumberOfWorkers *int32 `json:"maximumNumberOfWorkers,omitempty"`
+ GeoRegion *string `json:"geoRegion,omitempty"`
+ PerSiteScaling *bool `json:"perSiteScaling,omitempty"`
+ NumberOfSites *int32 `json:"numberOfSites,omitempty"`
+ ResourceGroup *string `json:"resourceGroup,omitempty"`
+ Reserved *bool `json:"reserved,omitempty"`
+ TargetWorkerCount *int32 `json:"targetWorkerCount,omitempty"`
+ TargetWorkerSizeID *int32 `json:"targetWorkerSizeId,omitempty"`
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+}
+
+// AppServicePlanCollection is collection of App Service plans.
+type AppServicePlanCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]AppServicePlan `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AppServicePlanCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client AppServicePlanCollection) AppServicePlanCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// AutoHealActions is actions which to take by the auto-heal module when a rule
+// is triggered.
+type AutoHealActions struct {
+ ActionType AutoHealActionType `json:"actionType,omitempty"`
+ CustomAction *AutoHealCustomAction `json:"customAction,omitempty"`
+ MinProcessExecutionTime *string `json:"minProcessExecutionTime,omitempty"`
+}
+
+// AutoHealCustomAction is custom action to be executed
+// when an auto heal rule is triggered.
+type AutoHealCustomAction struct {
+ Exe *string `json:"exe,omitempty"`
+ Parameters *string `json:"parameters,omitempty"`
+}
+
+// AutoHealRules is rules that can be defined for auto-heal.
+type AutoHealRules struct {
+ Triggers *AutoHealTriggers `json:"triggers,omitempty"`
+ Actions *AutoHealActions `json:"actions,omitempty"`
+}
+
+// AutoHealTriggers is triggers for auto-heal.
+type AutoHealTriggers struct {
+ Requests *RequestsBasedTrigger `json:"requests,omitempty"`
+ PrivateBytesInKB *int32 `json:"privateBytesInKB,omitempty"`
+ StatusCodes *[]StatusCodesBasedTrigger `json:"statusCodes,omitempty"`
+ SlowRequests *SlowRequestsBasedTrigger `json:"slowRequests,omitempty"`
+}
+
+// AzureBlobStorageApplicationLogsConfig is application logs azure blob storage
+// configuration.
+type AzureBlobStorageApplicationLogsConfig struct {
+ Level LogLevel `json:"level,omitempty"`
+ SasURL *string `json:"sasUrl,omitempty"`
+ RetentionInDays *int32 `json:"retentionInDays,omitempty"`
+}
+
+// AzureBlobStorageHTTPLogsConfig is http logs to azure blob storage
+// configuration.
+type AzureBlobStorageHTTPLogsConfig struct {
+ SasURL *string `json:"sasUrl,omitempty"`
+ RetentionInDays *int32 `json:"retentionInDays,omitempty"`
+ Enabled *bool `json:"enabled,omitempty"`
+}
+
+// AzureTableStorageApplicationLogsConfig is application logs to Azure table
+// storage configuration.
+type AzureTableStorageApplicationLogsConfig struct {
+ Level LogLevel `json:"level,omitempty"`
+ SasURL *string `json:"sasUrl,omitempty"`
+}
+
+// BackupItem is backup description.
+type BackupItem struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *BackupItemProperties `json:"properties,omitempty"`
+}
+
+// BackupItemProperties is backupItem resource specific properties
+type BackupItemProperties struct {
+ BackupID *int32 `json:"id,omitempty"`
+ StorageAccountURL *string `json:"storageAccountUrl,omitempty"`
+ BlobName *string `json:"blobName,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Status BackupItemStatus `json:"status,omitempty"`
+ SizeInBytes *int64 `json:"sizeInBytes,omitempty"`
+ Created *date.Time `json:"created,omitempty"`
+ Log *string `json:"log,omitempty"`
+ Databases *[]DatabaseBackupSetting `json:"databases,omitempty"`
+ Scheduled *bool `json:"scheduled,omitempty"`
+ LastRestoreTimeStamp *date.Time `json:"lastRestoreTimeStamp,omitempty"`
+ FinishedTimeStamp *date.Time `json:"finishedTimeStamp,omitempty"`
+ CorrelationID *string `json:"correlationId,omitempty"`
+ WebsiteSizeInBytes *int64 `json:"websiteSizeInBytes,omitempty"`
+}
+
+// BackupItemCollection is collection of backup items.
+type BackupItemCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]BackupItem `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// BackupItemCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client BackupItemCollection) BackupItemCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// BackupRequest is description of a backup which will be performed.
+type BackupRequest struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *BackupRequestProperties `json:"properties,omitempty"`
+}
+
+// BackupRequestProperties is backupRequest resource specific properties
+type BackupRequestProperties struct {
+ BackupRequestName *string `json:"name,omitempty"`
+ Enabled *bool `json:"enabled,omitempty"`
+ StorageAccountURL *string `json:"storageAccountUrl,omitempty"`
+ BackupSchedule *BackupSchedule `json:"backupSchedule,omitempty"`
+ Databases *[]DatabaseBackupSetting `json:"databases,omitempty"`
+ Type BackupRestoreOperationType `json:"type,omitempty"`
+}
+
+// BackupSchedule is description of a backup schedule. Describes how often
+// should be the backup performed and what should be the retention policy.
+type BackupSchedule struct {
+ FrequencyInterval *int32 `json:"frequencyInterval,omitempty"`
+ FrequencyUnit FrequencyUnit `json:"frequencyUnit,omitempty"`
+ KeepAtLeastOneBackup *bool `json:"keepAtLeastOneBackup,omitempty"`
+ RetentionPeriodInDays *int32 `json:"retentionPeriodInDays,omitempty"`
+ StartTime *date.Time `json:"startTime,omitempty"`
+ LastExecutionTime *date.Time `json:"lastExecutionTime,omitempty"`
+}
+
+// Capability is describes the capabilities/features allowed for a specific
+// SKU.
+type Capability struct {
+ Name *string `json:"name,omitempty"`
+ Value *string `json:"value,omitempty"`
+ Reason *string `json:"reason,omitempty"`
+}
+
+// Certificate is sSL certificate for an app.
+type Certificate struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *CertificateProperties `json:"properties,omitempty"`
+}
+
+// CertificateProperties is certificate resource specific properties
+type CertificateProperties struct {
+ FriendlyName *string `json:"friendlyName,omitempty"`
+ SubjectName *string `json:"subjectName,omitempty"`
+ HostNames *[]string `json:"hostNames,omitempty"`
+ PfxBlob *[]byte `json:"pfxBlob,omitempty"`
+ SiteName *string `json:"siteName,omitempty"`
+ SelfLink *string `json:"selfLink,omitempty"`
+ Issuer *string `json:"issuer,omitempty"`
+ IssueDate *date.Time `json:"issueDate,omitempty"`
+ ExpirationDate *date.Time `json:"expirationDate,omitempty"`
+ Password *string `json:"password,omitempty"`
+ Thumbprint *string `json:"thumbprint,omitempty"`
+ Valid *bool `json:"valid,omitempty"`
+ CerBlob *string `json:"cerBlob,omitempty"`
+ PublicKeyHash *string `json:"publicKeyHash,omitempty"`
+ HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"`
+ KeyVaultID *string `json:"keyVaultId,omitempty"`
+ KeyVaultSecretName *string `json:"keyVaultSecretName,omitempty"`
+ KeyVaultSecretStatus KeyVaultSecretStatus `json:"keyVaultSecretStatus,omitempty"`
+ GeoRegion *string `json:"geoRegion,omitempty"`
+ Name *string `json:"name,omitempty"`
+ ServerFarmID *string `json:"serverFarmId,omitempty"`
+}
+
+// CertificateCollection is collection of certificates.
+type CertificateCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]Certificate `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// CertificateCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client CertificateCollection) CertificateCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// CertificateDetails is sSL certificate details.
+type CertificateDetails struct {
+ Version *int32 `json:"version,omitempty"`
+ SerialNumber *string `json:"serialNumber,omitempty"`
+ Thumbprint *string `json:"thumbprint,omitempty"`
+ Subject *string `json:"subject,omitempty"`
+ NotBefore *date.Time `json:"notBefore,omitempty"`
+ NotAfter *date.Time `json:"notAfter,omitempty"`
+ SignatureAlgorithm *string `json:"signatureAlgorithm,omitempty"`
+ Issuer *string `json:"issuer,omitempty"`
+ RawData *string `json:"rawData,omitempty"`
+}
+
+// CertificateEmail is sSL certificate email.
+type CertificateEmail struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *CertificateEmailProperties `json:"properties,omitempty"`
+}
+
+// CertificateEmailProperties is certificateEmail resource specific properties
+type CertificateEmailProperties struct {
+ EmailID *string `json:"emailId,omitempty"`
+ TimeStamp *date.Time `json:"timeStamp,omitempty"`
+}
+
+// CertificateOrderAction is certificate order action.
+type CertificateOrderAction struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *CertificateOrderActionProperties `json:"properties,omitempty"`
+}
+
+// CertificateOrderActionProperties is certificateOrderAction resource specific
+// properties
+type CertificateOrderActionProperties struct {
+ Type CertificateOrderActionType `json:"type,omitempty"`
+ CreatedAt *date.Time `json:"createdAt,omitempty"`
+}
+
+// CloningInfo is information needed for cloning operation.
+type CloningInfo struct {
+ CorrelationID *string `json:"correlationId,omitempty"`
+ Overwrite *bool `json:"overwrite,omitempty"`
+ CloneCustomHostNames *bool `json:"cloneCustomHostNames,omitempty"`
+ CloneSourceControl *bool `json:"cloneSourceControl,omitempty"`
+ SourceWebAppID *string `json:"sourceWebAppId,omitempty"`
+ HostingEnvironment *string `json:"hostingEnvironment,omitempty"`
+ AppSettingsOverrides *map[string]*string `json:"appSettingsOverrides,omitempty"`
+ ConfigureLoadBalancing *bool `json:"configureLoadBalancing,omitempty"`
+ TrafficManagerProfileID *string `json:"trafficManagerProfileId,omitempty"`
+ TrafficManagerProfileName *string `json:"trafficManagerProfileName,omitempty"`
+ IgnoreQuotas *bool `json:"ignoreQuotas,omitempty"`
+}
+
+// ConnectionStringDictionary is string dictionary resource.
+type ConnectionStringDictionary struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ Properties *map[string]*ConnStringValueTypePair `json:"properties,omitempty"`
+}
+
+// ConnStringInfo is database connection string information.
+type ConnStringInfo struct {
+ Name *string `json:"name,omitempty"`
+ ConnectionString *string `json:"connectionString,omitempty"`
+ Type ConnectionStringType `json:"type,omitempty"`
+}
+
+// ConnStringValueTypePair is database connection string value to type pair.
+type ConnStringValueTypePair struct {
+ Value *string `json:"value,omitempty"`
+ Type ConnectionStringType `json:"type,omitempty"`
+}
+
+// Contact is contact information for domain registration. If 'Domain Privacy'
+// option is not selected then the contact information is made publicly
+// available through the Whois
+// directories as per ICANN requirements.
+type Contact struct {
+ AddressMailing *Address `json:"addressMailing,omitempty"`
+ Email *string `json:"email,omitempty"`
+ Fax *string `json:"fax,omitempty"`
+ JobTitle *string `json:"jobTitle,omitempty"`
+ NameFirst *string `json:"nameFirst,omitempty"`
+ NameLast *string `json:"nameLast,omitempty"`
+ NameMiddle *string `json:"nameMiddle,omitempty"`
+ Organization *string `json:"organization,omitempty"`
+ Phone *string `json:"phone,omitempty"`
+}
+
+// CorsSettings is cross-Origin Resource Sharing (CORS) settings for the app.
+type CorsSettings struct {
+ AllowedOrigins *[]string `json:"allowedOrigins,omitempty"`
+}
+
+// CsmMoveResourceEnvelope is object with a list of the resources that need to
+// be moved and the resource group they should be moved to.
+type CsmMoveResourceEnvelope struct {
+ TargetResourceGroup *string `json:"targetResourceGroup,omitempty"`
+ Resources *[]string `json:"resources,omitempty"`
+}
+
+// CsmPublishingProfileOptions is publishing options for requested profile.
+type CsmPublishingProfileOptions struct {
+ Format PublishingProfileFormat `json:"format,omitempty"`
+}
+
+// CsmSiteRecoveryEntity is details about app recovery operation.
+type CsmSiteRecoveryEntity struct {
+ SnapshotTime *date.Time `json:"snapshotTime,omitempty"`
+ SiteName *string `json:"siteName,omitempty"`
+ SlotName *string `json:"slotName,omitempty"`
+}
+
+// CsmSlotEntity is deployment slot parameters.
+type CsmSlotEntity struct {
+ TargetSlot *string `json:"targetSlot,omitempty"`
+ PreserveVnet *bool `json:"preserveVnet,omitempty"`
+}
+
+// CsmUsageQuota is usage of the quota resource.
+type CsmUsageQuota struct {
+ Unit *string `json:"unit,omitempty"`
+ NextResetTime *date.Time `json:"nextResetTime,omitempty"`
+ CurrentValue *int64 `json:"currentValue,omitempty"`
+ Limit *int64 `json:"limit,omitempty"`
+ Name *LocalizableString `json:"name,omitempty"`
+}
+
+// CsmUsageQuotaCollection is collection of CSM usage quotas.
+type CsmUsageQuotaCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]CsmUsageQuota `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// CsmUsageQuotaCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client CsmUsageQuotaCollection) CsmUsageQuotaCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// CustomHostnameAnalysisResult is custom domain analysis.
+type CustomHostnameAnalysisResult struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *CustomHostnameAnalysisResultProperties `json:"properties,omitempty"`
+}
+
+// CustomHostnameAnalysisResultProperties is customHostnameAnalysisResult
+// resource specific properties
+type CustomHostnameAnalysisResultProperties struct {
+ IsHostnameAlreadyVerified *bool `json:"isHostnameAlreadyVerified,omitempty"`
+ CustomDomainVerificationTest DNSVerificationTestResult `json:"customDomainVerificationTest,omitempty"`
+ CustomDomainVerificationFailureInfo *ErrorEntity `json:"customDomainVerificationFailureInfo,omitempty"`
+ HasConflictOnScaleUnit *bool `json:"hasConflictOnScaleUnit,omitempty"`
+ HasConflictAcrossSubscription *bool `json:"hasConflictAcrossSubscription,omitempty"`
+ ConflictingAppResourceID *string `json:"conflictingAppResourceId,omitempty"`
+ CNameRecords *[]string `json:"cNameRecords,omitempty"`
+ TxtRecords *[]string `json:"txtRecords,omitempty"`
+ ARecords *[]string `json:"aRecords,omitempty"`
+ AlternateCNameRecords *[]string `json:"alternateCNameRecords,omitempty"`
+ AlternateTxtRecords *[]string `json:"alternateTxtRecords,omitempty"`
+}
+
+// DatabaseBackupSetting is database backup settings.
+type DatabaseBackupSetting struct {
+ DatabaseType DatabaseType `json:"databaseType,omitempty"`
+ Name *string `json:"name,omitempty"`
+ ConnectionStringName *string `json:"connectionStringName,omitempty"`
+ ConnectionString *string `json:"connectionString,omitempty"`
+}
+
+// DeletedSite is a deleted app.
+type DeletedSite struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *DeletedSiteProperties `json:"properties,omitempty"`
+}
+
+// DeletedSiteProperties is deletedSite resource specific properties
+type DeletedSiteProperties struct {
+ DeletedTimestamp *date.Time `json:"deletedTimestamp,omitempty"`
+ State *string `json:"state,omitempty"`
+ HostNames *[]string `json:"hostNames,omitempty"`
+ RepositorySiteName *string `json:"repositorySiteName,omitempty"`
+ UsageState UsageState `json:"usageState,omitempty"`
+ Enabled *bool `json:"enabled,omitempty"`
+ EnabledHostNames *[]string `json:"enabledHostNames,omitempty"`
+ AvailabilityState SiteAvailabilityState `json:"availabilityState,omitempty"`
+ HostNameSslStates *[]HostNameSslState `json:"hostNameSslStates,omitempty"`
+ ServerFarmID *string `json:"serverFarmId,omitempty"`
+ Reserved *bool `json:"reserved,omitempty"`
+ LastModifiedTimeUtc *date.Time `json:"lastModifiedTimeUtc,omitempty"`
+ SiteConfig *SiteConfig `json:"siteConfig,omitempty"`
+ TrafficManagerHostNames *[]string `json:"trafficManagerHostNames,omitempty"`
+ PremiumAppDeployed *bool `json:"premiumAppDeployed,omitempty"`
+ ScmSiteAlsoStopped *bool `json:"scmSiteAlsoStopped,omitempty"`
+ TargetSwapSlot *string `json:"targetSwapSlot,omitempty"`
+ HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"`
+ MicroService *string `json:"microService,omitempty"`
+ GatewaySiteName *string `json:"gatewaySiteName,omitempty"`
+ ClientAffinityEnabled *bool `json:"clientAffinityEnabled,omitempty"`
+ ClientCertEnabled *bool `json:"clientCertEnabled,omitempty"`
+ HostNamesDisabled *bool `json:"hostNamesDisabled,omitempty"`
+ OutboundIPAddresses *string `json:"outboundIpAddresses,omitempty"`
+ ContainerSize *int32 `json:"containerSize,omitempty"`
+ DailyMemoryTimeQuota *int32 `json:"dailyMemoryTimeQuota,omitempty"`
+ SuspendedTill *date.Time `json:"suspendedTill,omitempty"`
+ MaxNumberOfWorkers *int32 `json:"maxNumberOfWorkers,omitempty"`
+ CloningInfo *CloningInfo `json:"cloningInfo,omitempty"`
+ ResourceGroup *string `json:"resourceGroup,omitempty"`
+ IsDefaultContainer *bool `json:"isDefaultContainer,omitempty"`
+ DefaultHostName *string `json:"defaultHostName,omitempty"`
+ SlotSwapStatus *SlotSwapStatus `json:"slotSwapStatus,omitempty"`
+}
+
+// DeletedWebAppCollection is collection of deleted apps.
+type DeletedWebAppCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]DeletedSite `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// DeletedWebAppCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DeletedWebAppCollection) DeletedWebAppCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// Deployment is user crendentials used for publishing activity.
+type Deployment struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *DeploymentProperties `json:"properties,omitempty"`
+}
+
+// DeploymentProperties is deployment resource specific properties
+type DeploymentProperties struct {
+ ID *string `json:"id,omitempty"`
+ Status *int32 `json:"status,omitempty"`
+ Message *string `json:"message,omitempty"`
+ Author *string `json:"author,omitempty"`
+ Deployer *string `json:"deployer,omitempty"`
+ AuthorEmail *string `json:"authorEmail,omitempty"`
+ StartTime *date.Time `json:"startTime,omitempty"`
+ EndTime *date.Time `json:"endTime,omitempty"`
+ Active *bool `json:"active,omitempty"`
+ Details *string `json:"details,omitempty"`
+}
+
+// DeploymentCollection is collection of app deployments.
+type DeploymentCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]Deployment `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// DeploymentCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DeploymentCollection) DeploymentCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// Domain is information about a domain.
+type Domain struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *DomainProperties `json:"properties,omitempty"`
+}
+
+// DomainProperties is domain resource specific properties
+type DomainProperties struct {
+ ContactAdmin *Contact `json:"contactAdmin,omitempty"`
+ ContactBilling *Contact `json:"contactBilling,omitempty"`
+ ContactRegistrant *Contact `json:"contactRegistrant,omitempty"`
+ ContactTech *Contact `json:"contactTech,omitempty"`
+ RegistrationStatus DomainStatus `json:"registrationStatus,omitempty"`
+ ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
+ NameServers *[]string `json:"nameServers,omitempty"`
+ Privacy *bool `json:"privacy,omitempty"`
+ CreatedTime *date.Time `json:"createdTime,omitempty"`
+ ExpirationTime *date.Time `json:"expirationTime,omitempty"`
+ LastRenewedTime *date.Time `json:"lastRenewedTime,omitempty"`
+ AutoRenew *bool `json:"autoRenew,omitempty"`
+ ReadyForDNSRecordManagement *bool `json:"readyForDnsRecordManagement,omitempty"`
+ ManagedHostNames *[]HostName `json:"managedHostNames,omitempty"`
+ Consent *DomainPurchaseConsent `json:"consent,omitempty"`
+ DomainNotRenewableReasons *[]string `json:"domainNotRenewableReasons,omitempty"`
+ DNSType DNSType `json:"dnsType,omitempty"`
+ DNSZoneID *string `json:"dnsZoneId,omitempty"`
+ TargetDNSType DNSType `json:"targetDnsType,omitempty"`
+ AuthCode *string `json:"authCode,omitempty"`
+}
+
+// DomainAvailablilityCheckResult is domain availablility check result.
+type DomainAvailablilityCheckResult struct {
+ autorest.Response `json:"-"`
+ Name *string `json:"name,omitempty"`
+ Available *bool `json:"available,omitempty"`
+ DomainType DomainType `json:"domainType,omitempty"`
+}
+
+// DomainCollection is collection of domains.
+type DomainCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]Domain `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// DomainCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DomainCollection) DomainCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// DomainControlCenterSsoRequest is single sign-on request information for
+// domain management.
+type DomainControlCenterSsoRequest struct {
+ autorest.Response `json:"-"`
+ URL *string `json:"url,omitempty"`
+ PostParameterKey *string `json:"postParameterKey,omitempty"`
+ PostParameterValue *string `json:"postParameterValue,omitempty"`
+}
+
+// DomainOwnershipIdentifier is domain ownership Identifier.
+type DomainOwnershipIdentifier struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *DomainOwnershipIdentifierProperties `json:"properties,omitempty"`
+}
+
+// DomainOwnershipIdentifierProperties is domainOwnershipIdentifier resource
+// specific properties
+type DomainOwnershipIdentifierProperties struct {
+ OwnershipID *string `json:"ownershipId,omitempty"`
+}
+
+// DomainOwnershipIdentifierCollection is collection of domain ownership
+// identifiers.
+type DomainOwnershipIdentifierCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]DomainOwnershipIdentifier `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// DomainOwnershipIdentifierCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client DomainOwnershipIdentifierCollection) DomainOwnershipIdentifierCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// DomainPurchaseConsent is domain purchase consent object, representing
+// acceptance of applicable legal agreements.
+type DomainPurchaseConsent struct {
+ AgreementKeys *[]string `json:"agreementKeys,omitempty"`
+ AgreedBy *string `json:"agreedBy,omitempty"`
+ AgreedAt *date.Time `json:"agreedAt,omitempty"`
+}
+
+// DomainRecommendationSearchParameters is domain recommendation search
+// parameters.
+type DomainRecommendationSearchParameters struct {
+ Keywords *string `json:"keywords,omitempty"`
+ MaxDomainRecommendations *int32 `json:"maxDomainRecommendations,omitempty"`
+}
+
+// EnabledConfig is enabled configuration.
+type EnabledConfig struct {
+ Enabled *bool `json:"enabled,omitempty"`
+}
+
+// ErrorEntity is body of the error response returned from the API.
+type ErrorEntity struct {
+ ExtendedCode *string `json:"extendedCode,omitempty"`
+ MessageTemplate *string `json:"messageTemplate,omitempty"`
+ Parameters *[]string `json:"parameters,omitempty"`
+ InnerErrors *[]ErrorEntity `json:"innerErrors,omitempty"`
+ Code *string `json:"code,omitempty"`
+ Message *string `json:"message,omitempty"`
+}
+
+// Experiments is routing rules in production experiments.
+type Experiments struct {
+ RampUpRules *[]RampUpRule `json:"rampUpRules,omitempty"`
+}
+
+// FileSystemApplicationLogsConfig is application logs to file system
+// configuration.
+type FileSystemApplicationLogsConfig struct {
+ Level LogLevel `json:"level,omitempty"`
+}
+
+// FileSystemHTTPLogsConfig is http logs to file system configuration.
+type FileSystemHTTPLogsConfig struct {
+ RetentionInMb *int32 `json:"retentionInMb,omitempty"`
+ RetentionInDays *int32 `json:"retentionInDays,omitempty"`
+ Enabled *bool `json:"enabled,omitempty"`
+}
+
+// GeoRegion is geographical region.
+type GeoRegion struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *GeoRegionProperties `json:"properties,omitempty"`
+}
+
+// GeoRegionProperties is geoRegion resource specific properties
+type GeoRegionProperties struct {
+ Name *string `json:"name,omitempty"`
+ Description *string `json:"description,omitempty"`
+ DisplayName *string `json:"displayName,omitempty"`
+}
+
+// GeoRegionCollection is collection of geographical regions.
+type GeoRegionCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]GeoRegion `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// GeoRegionCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client GeoRegionCollection) GeoRegionCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// GlobalCsmSkuDescription is a Global SKU Description.
+type GlobalCsmSkuDescription struct {
+ Name *string `json:"name,omitempty"`
+ Tier *string `json:"tier,omitempty"`
+ Capacity *SkuCapacity `json:"capacity,omitempty"`
+ Locations *[]string `json:"locations,omitempty"`
+ Capabilities *[]Capability `json:"capabilities,omitempty"`
+}
+
+// HandlerMapping is the IIS handler mappings used to define which handler
+// processes HTTP requests with certain extension.
+// For example, it is used to configure php-cgi.exe process to handle all HTTP
+// requests with *.php extension.
+type HandlerMapping struct {
+ Extension *string `json:"extension,omitempty"`
+ ScriptProcessor *string `json:"scriptProcessor,omitempty"`
+ Arguments *string `json:"arguments,omitempty"`
+}
+
+// HostingEnvironmentDiagnostics is diagnostics for an App Service Environment.
+type HostingEnvironmentDiagnostics struct {
+ autorest.Response `json:"-"`
+ Name *string `json:"name,omitempty"`
+ DiagnosicsOutput *string `json:"diagnosicsOutput,omitempty"`
+}
+
+// HostingEnvironmentProfile is specification for an App Service Environment to
+// use for this resource.
+type HostingEnvironmentProfile struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Type *string `json:"type,omitempty"`
+}
+
+// HostName is details of a hostname derived from a domain.
+type HostName struct {
+ Name *string `json:"name,omitempty"`
+ SiteNames *[]string `json:"siteNames,omitempty"`
+ AzureResourceName *string `json:"azureResourceName,omitempty"`
+ AzureResourceType AzureResourceType `json:"azureResourceType,omitempty"`
+ CustomHostNameDNSRecordType CustomHostNameDNSRecordType `json:"customHostNameDnsRecordType,omitempty"`
+ HostNameType HostNameType `json:"hostNameType,omitempty"`
+}
+
+// HostNameBinding is a hostname binding object.
+type HostNameBinding struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *HostNameBindingProperties `json:"properties,omitempty"`
+}
+
+// HostNameBindingProperties is hostNameBinding resource specific properties
+type HostNameBindingProperties struct {
+ Name *string `json:"name,omitempty"`
+ SiteName *string `json:"siteName,omitempty"`
+ DomainID *string `json:"domainId,omitempty"`
+ AzureResourceName *string `json:"azureResourceName,omitempty"`
+ AzureResourceType AzureResourceType `json:"azureResourceType,omitempty"`
+ CustomHostNameDNSRecordType CustomHostNameDNSRecordType `json:"customHostNameDnsRecordType,omitempty"`
+ HostNameType HostNameType `json:"hostNameType,omitempty"`
+ SslState SslState `json:"sslState,omitempty"`
+ Thumbprint *string `json:"thumbprint,omitempty"`
+ VirtualIP *string `json:"virtualIP,omitempty"`
+}
+
+// HostNameBindingCollection is collection of hostname bindings.
+type HostNameBindingCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]HostNameBinding `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// HostNameBindingCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client HostNameBindingCollection) HostNameBindingCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// HostNameSslState is sSL-enabled hostname.
+type HostNameSslState struct {
+ Name *string `json:"name,omitempty"`
+ SslState SslState `json:"sslState,omitempty"`
+ VirtualIP *string `json:"virtualIP,omitempty"`
+ Thumbprint *string `json:"thumbprint,omitempty"`
+ ToUpdate *bool `json:"toUpdate,omitempty"`
+ HostType HostType `json:"hostType,omitempty"`
+}
+
+// HTTPLogsConfig is http logs configuration.
+type HTTPLogsConfig struct {
+ FileSystem *FileSystemHTTPLogsConfig `json:"fileSystem,omitempty"`
+ AzureBlobStorage *AzureBlobStorageHTTPLogsConfig `json:"azureBlobStorage,omitempty"`
+}
+
+// HybridConnection is hybrid Connection contract. This is used to configure a
+// Hybrid Connection.
+type HybridConnection struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *HybridConnectionProperties `json:"properties,omitempty"`
+}
+
+// HybridConnectionProperties is hybridConnection resource specific properties
+type HybridConnectionProperties struct {
+ ServiceBusNamespace *string `json:"serviceBusNamespace,omitempty"`
+ RelayName *string `json:"relayName,omitempty"`
+ RelayArmURI *string `json:"relayArmUri,omitempty"`
+ Hostname *string `json:"hostname,omitempty"`
+ Port *int32 `json:"port,omitempty"`
+ SendKeyName *string `json:"sendKeyName,omitempty"`
+ SendKeyValue *string `json:"sendKeyValue,omitempty"`
+}
+
+// HybridConnectionCollection is collection of hostname bindings.
+type HybridConnectionCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]HybridConnection `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// HybridConnectionCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client HybridConnectionCollection) HybridConnectionCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// HybridConnectionKey is hybrid Connection key contract. This has the send key
+// name and value for a Hybrid Connection.
+type HybridConnectionKey struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *HybridConnectionKeyProperties `json:"properties,omitempty"`
+}
+
+// HybridConnectionKeyProperties is hybridConnectionKey resource specific
+// properties
+type HybridConnectionKeyProperties struct {
+ SendKeyName *string `json:"sendKeyName,omitempty"`
+ SendKeyValue *string `json:"sendKeyValue,omitempty"`
+}
+
+// HybridConnectionLimits is hybrid Connection limits contract. This is used to
+// return the plan limits of Hybrid Connections.
+type HybridConnectionLimits struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *HybridConnectionLimitsProperties `json:"properties,omitempty"`
+}
+
+// HybridConnectionLimitsProperties is hybridConnectionLimits resource specific
+// properties
+type HybridConnectionLimitsProperties struct {
+ Current *int32 `json:"current,omitempty"`
+ Maximum *int32 `json:"maximum,omitempty"`
+}
+
+// Identifier is identifier.
+type Identifier struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *IdentifierProperties `json:"properties,omitempty"`
+}
+
+// IdentifierProperties is identifier resource specific properties
+type IdentifierProperties struct {
+ ID *string `json:"id,omitempty"`
+}
+
+// IdentifierCollection is collection of identifiers.
+type IdentifierCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]Identifier `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// IdentifierCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client IdentifierCollection) IdentifierCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// IPSecurityRestriction is iP security restriction on an app.
+type IPSecurityRestriction struct {
+ IPAddress *string `json:"ipAddress,omitempty"`
+ SubnetMask *string `json:"subnetMask,omitempty"`
+}
+
+// ListCapability is
+type ListCapability struct {
+ autorest.Response `json:"-"`
+ Value *[]Capability `json:"value,omitempty"`
+}
+
+// ListCertificateEmail is
+type ListCertificateEmail struct {
+ autorest.Response `json:"-"`
+ Value *[]CertificateEmail `json:"value,omitempty"`
+}
+
+// ListCertificateOrderAction is
+type ListCertificateOrderAction struct {
+ autorest.Response `json:"-"`
+ Value *[]CertificateOrderAction `json:"value,omitempty"`
+}
+
+// ListHostingEnvironmentDiagnostics is
+type ListHostingEnvironmentDiagnostics struct {
+ autorest.Response `json:"-"`
+ Value *[]HostingEnvironmentDiagnostics `json:"value,omitempty"`
+}
+
+// ListOperation is
+type ListOperation struct {
+ autorest.Response `json:"-"`
+ Value *[]Operation `json:"value,omitempty"`
+}
+
+// ListRecommendation is
+type ListRecommendation struct {
+ autorest.Response `json:"-"`
+ Value *[]Recommendation `json:"value,omitempty"`
+}
+
+// ListSiteConfigurationSnapshotInfo is
+type ListSiteConfigurationSnapshotInfo struct {
+ autorest.Response `json:"-"`
+ Value *[]SiteConfigurationSnapshotInfo `json:"value,omitempty"`
+}
+
+// ListVnetInfo is
+type ListVnetInfo struct {
+ autorest.Response `json:"-"`
+ Value *[]VnetInfo `json:"value,omitempty"`
+}
+
+// ListVnetRoute is
+type ListVnetRoute struct {
+ autorest.Response `json:"-"`
+ Value *[]VnetRoute `json:"value,omitempty"`
+}
+
+// LocalizableString is localizable string object containing the name and a
+// localized value.
+type LocalizableString struct {
+ Value *string `json:"value,omitempty"`
+ LocalizedValue *string `json:"localizedValue,omitempty"`
+}
+
+// MetricAvailabilily is metric availability and retention.
+type MetricAvailabilily struct {
+ TimeGrain *string `json:"timeGrain,omitempty"`
+ Retention *string `json:"retention,omitempty"`
+}
+
+// MetricDefinition is metadata for a metric.
+type MetricDefinition struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *MetricDefinitionProperties `json:"properties,omitempty"`
+}
+
+// MetricDefinitionProperties is metricDefinition resource specific properties
+type MetricDefinitionProperties struct {
+ Name *string `json:"name,omitempty"`
+ Unit *string `json:"unit,omitempty"`
+ PrimaryAggregationType *string `json:"primaryAggregationType,omitempty"`
+ MetricAvailabilities *[]MetricAvailabilily `json:"metricAvailabilities,omitempty"`
+ DisplayName *string `json:"displayName,omitempty"`
+}
+
+// MigrateMySQLRequest is mySQL migration request.
+type MigrateMySQLRequest struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *MigrateMySQLRequestProperties `json:"properties,omitempty"`
+}
+
+// MigrateMySQLRequestProperties is migrateMySqlRequest resource specific
+// properties
+type MigrateMySQLRequestProperties struct {
+ ConnectionString *string `json:"connectionString,omitempty"`
+}
+
+// MigrateMySQLStatus is mySQL migration status.
+type MigrateMySQLStatus struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *MigrateMySQLStatusProperties `json:"properties,omitempty"`
+}
+
+// MigrateMySQLStatusProperties is migrateMySqlStatus resource specific
+// properties
+type MigrateMySQLStatusProperties struct {
+ MigrationOperationStatus OperationStatus `json:"migrationOperationStatus,omitempty"`
+ OperationID *string `json:"operationId,omitempty"`
+ LocalMySQLEnabled *bool `json:"localMySqlEnabled,omitempty"`
+}
+
+// NameIdentifier is identifies an object.
+type NameIdentifier struct {
+ Name *string `json:"name,omitempty"`
+}
+
+// NameIdentifierCollection is collection of domain name identifiers.
+type NameIdentifierCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]NameIdentifier `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// NameIdentifierCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client NameIdentifierCollection) NameIdentifierCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// NameValuePair is name value pair.
+type NameValuePair struct {
+ Name *string `json:"name,omitempty"`
+ Value *string `json:"value,omitempty"`
+}
+
+// NetworkAccessControlEntry is network access control entry.
+type NetworkAccessControlEntry struct {
+ Action AccessControlEntryAction `json:"action,omitempty"`
+ Description *string `json:"description,omitempty"`
+ Order *int32 `json:"order,omitempty"`
+ RemoteSubnet *string `json:"remoteSubnet,omitempty"`
+}
+
+// NetworkFeatures is full view of network features for an app (presently VNET
+// integration and Hybrid Connections).
+type NetworkFeatures struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *NetworkFeaturesProperties `json:"properties,omitempty"`
+}
+
+// NetworkFeaturesProperties is networkFeatures resource specific properties
+type NetworkFeaturesProperties struct {
+ VirtualNetworkName *string `json:"virtualNetworkName,omitempty"`
+ VirtualNetworkConnection *VnetInfo `json:"virtualNetworkConnection,omitempty"`
+ HybridConnections *[]RelayServiceConnectionEntity `json:"hybridConnections,omitempty"`
+ HybridConnectionsV2 *[]HybridConnection `json:"hybridConnectionsV2,omitempty"`
+}
+
+// Operation is operation.
+type Operation struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Status OperationStatus `json:"status,omitempty"`
+ Errors *[]ErrorEntity `json:"errors,omitempty"`
+ CreatedTime *date.Time `json:"createdTime,omitempty"`
+ ModifiedTime *date.Time `json:"modifiedTime,omitempty"`
+ ExpirationTime *date.Time `json:"expirationTime,omitempty"`
+ GeoMasterOperationID *string `json:"geoMasterOperationId,omitempty"`
+}
+
+// PerfMonCounterCollection is collection of performance monitor counters.
+type PerfMonCounterCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]PerfMonResponse `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// PerfMonCounterCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client PerfMonCounterCollection) PerfMonCounterCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// PerfMonResponse is performance monitor API response.
+type PerfMonResponse struct {
+ Code *string `json:"code,omitempty"`
+ Message *string `json:"message,omitempty"`
+ Data *PerfMonSet `json:"data,omitempty"`
+}
+
+// PerfMonSample is performance monitor sample in a set.
+type PerfMonSample struct {
+ Time *date.Time `json:"time,omitempty"`
+ InstanceName *string `json:"instanceName,omitempty"`
+ Value *float64 `json:"value,omitempty"`
+}
+
+// PerfMonSet is metric information.
+type PerfMonSet struct {
+ Name *string `json:"name,omitempty"`
+ StartTime *date.Time `json:"startTime,omitempty"`
+ EndTime *date.Time `json:"endTime,omitempty"`
+ TimeGrain *string `json:"timeGrain,omitempty"`
+ Values *[]PerfMonSample `json:"values,omitempty"`
+}
+
+// PremierAddOn is premier add-on.
+type PremierAddOn struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *PremierAddOnProperties `json:"properties,omitempty"`
+}
+
+// PremierAddOnProperties is premierAddOn resource specific properties
+type PremierAddOnProperties struct {
+ Sku *string `json:"sku,omitempty"`
+ Product *string `json:"product,omitempty"`
+ Vendor *string `json:"vendor,omitempty"`
+ PremierAddOnName *string `json:"name,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ MarketplacePublisher *string `json:"marketplacePublisher,omitempty"`
+ MarketplaceOffer *string `json:"marketplaceOffer,omitempty"`
+}
+
+// PremierAddOnOffer is premier add-on offer.
+type PremierAddOnOffer struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *PremierAddOnOfferProperties `json:"properties,omitempty"`
+}
+
+// PremierAddOnOfferProperties is premierAddOnOffer resource specific
+// properties
+type PremierAddOnOfferProperties struct {
+ Sku *string `json:"sku,omitempty"`
+ Product *string `json:"product,omitempty"`
+ Vendor *string `json:"vendor,omitempty"`
+ Name *string `json:"name,omitempty"`
+ PromoCodeRequired *bool `json:"promoCodeRequired,omitempty"`
+ Quota *int32 `json:"quota,omitempty"`
+ WebHostingPlanRestrictions AppServicePlanRestrictions `json:"webHostingPlanRestrictions,omitempty"`
+ PrivacyPolicyURL *string `json:"privacyPolicyUrl,omitempty"`
+ LegalTermsURL *string `json:"legalTermsUrl,omitempty"`
+ MarketplacePublisher *string `json:"marketplacePublisher,omitempty"`
+ MarketplaceOffer *string `json:"marketplaceOffer,omitempty"`
+}
+
+// PremierAddOnOfferCollection is collection of premier add-on offers.
+type PremierAddOnOfferCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]PremierAddOnOffer `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// PremierAddOnOfferCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client PremierAddOnOfferCollection) PremierAddOnOfferCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// PushSettings is push settings for the App.
+type PushSettings struct {
+ autorest.Response `json:"-"`
+ IsPushEnabled *bool `json:"isPushEnabled,omitempty"`
+ TagWhitelistJSON *string `json:"tagWhitelistJson,omitempty"`
+ TagsRequiringAuth *string `json:"tagsRequiringAuth,omitempty"`
+ DynamicTagsJSON *string `json:"dynamicTagsJson,omitempty"`
+}
+
+// RampUpRule is routing rules for ramp up testing. This rule allows to
+// redirect static traffic % to a slot or to gradually change routing % based
+// on performance.
+type RampUpRule struct {
+ ActionHostName *string `json:"actionHostName,omitempty"`
+ ReroutePercentage *float64 `json:"reroutePercentage,omitempty"`
+ ChangeStep *float64 `json:"changeStep,omitempty"`
+ ChangeIntervalInMinutes *int32 `json:"changeIntervalInMinutes,omitempty"`
+ MinReroutePercentage *float64 `json:"minReroutePercentage,omitempty"`
+ MaxReroutePercentage *float64 `json:"maxReroutePercentage,omitempty"`
+ ChangeDecisionCallbackURL *string `json:"changeDecisionCallbackUrl,omitempty"`
+ Name *string `json:"name,omitempty"`
+}
+
+// ReadCloser is
+type ReadCloser struct {
+ autorest.Response `json:"-"`
+ Value *io.ReadCloser `json:"value,omitempty"`
+}
+
+// Recommendation is represents a recommendation result generated by the
+// recommendation engine.
+type Recommendation struct {
+ CreationTime *date.Time `json:"creationTime,omitempty"`
+ RecommendationID *string `json:"recommendationId,omitempty"`
+ ResourceID *string `json:"resourceId,omitempty"`
+ ResourceScope ResourceScopeType `json:"resourceScope,omitempty"`
+ RuleName *string `json:"ruleName,omitempty"`
+ DisplayName *string `json:"displayName,omitempty"`
+ Message *string `json:"message,omitempty"`
+ Level NotificationLevel `json:"level,omitempty"`
+ Channels Channels `json:"channels,omitempty"`
+ Tags *[]string `json:"tags,omitempty"`
+ ActionName *string `json:"actionName,omitempty"`
+ StartTime *date.Time `json:"startTime,omitempty"`
+ EndTime *date.Time `json:"endTime,omitempty"`
+ NextNotificationTime *date.Time `json:"nextNotificationTime,omitempty"`
+ NotificationExpirationTime *date.Time `json:"notificationExpirationTime,omitempty"`
+ NotifiedTime *date.Time `json:"notifiedTime,omitempty"`
+ Score *float64 `json:"score,omitempty"`
+ IsDynamic *bool `json:"isDynamic,omitempty"`
+ ExtensionName *string `json:"extensionName,omitempty"`
+ BladeName *string `json:"bladeName,omitempty"`
+ ForwardLink *string `json:"forwardLink,omitempty"`
+}
+
+// RecommendationRule is represents a recommendation rule that the
+// recommendation engine can perform.
+type RecommendationRule struct {
+ autorest.Response `json:"-"`
+ Name *string `json:"name,omitempty"`
+ DisplayName *string `json:"displayName,omitempty"`
+ Message *string `json:"message,omitempty"`
+ RecommendationID *uuid.UUID `json:"recommendationId,omitempty"`
+ Description *string `json:"description,omitempty"`
+ ActionName *string `json:"actionName,omitempty"`
+ Level NotificationLevel `json:"level,omitempty"`
+ Channels Channels `json:"channels,omitempty"`
+ Tags *[]string `json:"tags,omitempty"`
+ IsDynamic *bool `json:"isDynamic,omitempty"`
+ ExtensionName *string `json:"extensionName,omitempty"`
+ BladeName *string `json:"bladeName,omitempty"`
+ ForwardLink *string `json:"forwardLink,omitempty"`
+}
+
+// RecoverResponse is response for an app recovery request.
+type RecoverResponse struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *RecoverResponseProperties `json:"properties,omitempty"`
+}
+
+// RecoverResponseProperties is recoverResponse resource specific properties
+type RecoverResponseProperties struct {
+ OperationID *string `json:"operationId,omitempty"`
+}
+
+// ReissueCertificateOrderRequest is class representing certificate reissue
+// request.
+type ReissueCertificateOrderRequest struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *ReissueCertificateOrderRequestProperties `json:"properties,omitempty"`
+}
+
+// ReissueCertificateOrderRequestProperties is reissueCertificateOrderRequest
+// resource specific properties
+type ReissueCertificateOrderRequestProperties struct {
+ KeySize *int32 `json:"keySize,omitempty"`
+ DelayExistingRevokeInHours *int32 `json:"delayExistingRevokeInHours,omitempty"`
+ Csr *string `json:"csr,omitempty"`
+ IsPrivateKeyExternal *bool `json:"isPrivateKeyExternal,omitempty"`
+}
+
+// RelayServiceConnectionEntity is hybrid Connection for an App Service app.
+type RelayServiceConnectionEntity struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *RelayServiceConnectionEntityProperties `json:"properties,omitempty"`
+}
+
+// RelayServiceConnectionEntityProperties is relayServiceConnectionEntity
+// resource specific properties
+type RelayServiceConnectionEntityProperties struct {
+ EntityName *string `json:"entityName,omitempty"`
+ EntityConnectionString *string `json:"entityConnectionString,omitempty"`
+ ResourceType *string `json:"resourceType,omitempty"`
+ ResourceConnectionString *string `json:"resourceConnectionString,omitempty"`
+ Hostname *string `json:"hostname,omitempty"`
+ Port *int32 `json:"port,omitempty"`
+ BiztalkURI *string `json:"biztalkUri,omitempty"`
+}
+
+// RenewCertificateOrderRequest is class representing certificate renew
+// request.
+type RenewCertificateOrderRequest struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *RenewCertificateOrderRequestProperties `json:"properties,omitempty"`
+}
+
+// RenewCertificateOrderRequestProperties is renewCertificateOrderRequest
+// resource specific properties
+type RenewCertificateOrderRequestProperties struct {
+ KeySize *int32 `json:"keySize,omitempty"`
+ Csr *string `json:"csr,omitempty"`
+ IsPrivateKeyExternal *bool `json:"isPrivateKeyExternal,omitempty"`
+}
+
+// RequestsBasedTrigger is trigger based on total requests.
+type RequestsBasedTrigger struct {
+ Count *int32 `json:"count,omitempty"`
+ TimeInterval *string `json:"timeInterval,omitempty"`
+}
+
+// Resource is azure resource.
+type Resource struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+}
+
+// ResourceCollection is collection of resources.
+type ResourceCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]string `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ResourceCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client ResourceCollection) ResourceCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// ResourceHealthMetadata is used for getting ResourceHealthCheck settings.
+type ResourceHealthMetadata struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *ResourceHealthMetadataProperties `json:"properties,omitempty"`
+}
+
+// ResourceHealthMetadataProperties is resourceHealthMetadata resource specific
+// properties
+type ResourceHealthMetadataProperties struct {
+ ID *string `json:"id,omitempty"`
+ Category *string `json:"category,omitempty"`
+ SignalAvailability *bool `json:"signalAvailability,omitempty"`
+}
+
+// ResourceMetric is object representing a metric for any resource .
+type ResourceMetric struct {
+ Name *ResourceMetricName `json:"name,omitempty"`
+ Unit *string `json:"unit,omitempty"`
+ TimeGrain *string `json:"timeGrain,omitempty"`
+ StartTime *date.Time `json:"startTime,omitempty"`
+ EndTime *date.Time `json:"endTime,omitempty"`
+ ResourceID *string `json:"resourceId,omitempty"`
+ ID *string `json:"id,omitempty"`
+ MetricValues *[]ResourceMetricValue `json:"metricValues,omitempty"`
+ Properties *[]ResourceMetricProperty `json:"properties,omitempty"`
+}
+
+// ResourceMetricAvailability is metrics availability and retention.
+type ResourceMetricAvailability struct {
+ TimeGrain *string `json:"timeGrain,omitempty"`
+ Retention *string `json:"retention,omitempty"`
+}
+
+// ResourceMetricCollection is collection of metric responses.
+type ResourceMetricCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]ResourceMetric `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ResourceMetricCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client ResourceMetricCollection) ResourceMetricCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// ResourceMetricDefinition is metadata for the metrics.
+type ResourceMetricDefinition struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *ResourceMetricDefinitionProperties `json:"properties,omitempty"`
+}
+
+// ResourceMetricDefinitionProperties is resourceMetricDefinition resource
+// specific properties
+type ResourceMetricDefinitionProperties struct {
+ Name *ResourceMetricName `json:"name,omitempty"`
+ Unit *string `json:"unit,omitempty"`
+ PrimaryAggregationType *string `json:"primaryAggregationType,omitempty"`
+ MetricAvailabilities *[]ResourceMetricAvailability `json:"metricAvailabilities,omitempty"`
+ ResourceURI *string `json:"resourceUri,omitempty"`
+ ID *string `json:"id,omitempty"`
+ Properties *map[string]*string `json:"properties,omitempty"`
+}
+
+// ResourceMetricDefinitionCollection is collection of metric definitions.
+type ResourceMetricDefinitionCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]ResourceMetricDefinition `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ResourceMetricDefinitionCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client ResourceMetricDefinitionCollection) ResourceMetricDefinitionCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// ResourceMetricName is name of a metric for any resource .
+type ResourceMetricName struct {
+ Value *string `json:"value,omitempty"`
+ LocalizedValue *string `json:"localizedValue,omitempty"`
+}
+
+// ResourceMetricProperty is resource metric property.
+type ResourceMetricProperty struct {
+ Key *string `json:"key,omitempty"`
+ Value *string `json:"value,omitempty"`
+}
+
+// ResourceMetricValue is value of resource metric.
+type ResourceMetricValue struct {
+ Timestamp *string `json:"timestamp,omitempty"`
+ Average *float64 `json:"average,omitempty"`
+ Minimum *float64 `json:"minimum,omitempty"`
+ Maximum *float64 `json:"maximum,omitempty"`
+ Total *float64 `json:"total,omitempty"`
+ Count *float64 `json:"count,omitempty"`
+ Properties *[]ResourceMetricProperty `json:"properties,omitempty"`
+}
+
+// ResourceNameAvailability is information regarding availbility of a resource
+// name.
+type ResourceNameAvailability struct {
+ autorest.Response `json:"-"`
+ NameAvailable *bool `json:"nameAvailable,omitempty"`
+ Reason InAvailabilityReasonType `json:"reason,omitempty"`
+ Message *string `json:"message,omitempty"`
+}
+
+// ResourceNameAvailabilityRequest is resource name availability request
+// content.
+type ResourceNameAvailabilityRequest struct {
+ Name *string `json:"name,omitempty"`
+ Type CheckNameResourceTypes `json:"type,omitempty"`
+ IsFqdn *bool `json:"isFqdn,omitempty"`
+}
+
+// RestoreRequest is description of a restore request.
+type RestoreRequest struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *RestoreRequestProperties `json:"properties,omitempty"`
+}
+
+// RestoreRequestProperties is restoreRequest resource specific properties
+type RestoreRequestProperties struct {
+ StorageAccountURL *string `json:"storageAccountUrl,omitempty"`
+ BlobName *string `json:"blobName,omitempty"`
+ Overwrite *bool `json:"overwrite,omitempty"`
+ SiteName *string `json:"siteName,omitempty"`
+ Databases *[]DatabaseBackupSetting `json:"databases,omitempty"`
+ IgnoreConflictingHostNames *bool `json:"ignoreConflictingHostNames,omitempty"`
+ OperationType BackupRestoreOperationType `json:"operationType,omitempty"`
+ AdjustConnectionStrings *bool `json:"adjustConnectionStrings,omitempty"`
+ HostingEnvironment *string `json:"hostingEnvironment,omitempty"`
+}
+
+// RestoreResponse is response for an app restore request.
+type RestoreResponse struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *RestoreResponseProperties `json:"properties,omitempty"`
+}
+
+// RestoreResponseProperties is restoreResponse resource specific properties
+type RestoreResponseProperties struct {
+ OperationID *string `json:"operationId,omitempty"`
+}
+
+// SetObject is
+type SetObject struct {
+ autorest.Response `json:"-"`
+ Value *map[string]interface{} `json:"value,omitempty"`
+}
+
+// Site is a web app, a mobile app backend, or an API app.
+type Site struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SiteProperties `json:"properties,omitempty"`
+}
+
+// SiteProperties is site resource specific properties
+type SiteProperties struct {
+ State *string `json:"state,omitempty"`
+ HostNames *[]string `json:"hostNames,omitempty"`
+ RepositorySiteName *string `json:"repositorySiteName,omitempty"`
+ UsageState UsageState `json:"usageState,omitempty"`
+ Enabled *bool `json:"enabled,omitempty"`
+ EnabledHostNames *[]string `json:"enabledHostNames,omitempty"`
+ AvailabilityState SiteAvailabilityState `json:"availabilityState,omitempty"`
+ HostNameSslStates *[]HostNameSslState `json:"hostNameSslStates,omitempty"`
+ ServerFarmID *string `json:"serverFarmId,omitempty"`
+ Reserved *bool `json:"reserved,omitempty"`
+ LastModifiedTimeUtc *date.Time `json:"lastModifiedTimeUtc,omitempty"`
+ SiteConfig *SiteConfig `json:"siteConfig,omitempty"`
+ TrafficManagerHostNames *[]string `json:"trafficManagerHostNames,omitempty"`
+ PremiumAppDeployed *bool `json:"premiumAppDeployed,omitempty"`
+ ScmSiteAlsoStopped *bool `json:"scmSiteAlsoStopped,omitempty"`
+ TargetSwapSlot *string `json:"targetSwapSlot,omitempty"`
+ HostingEnvironmentProfile *HostingEnvironmentProfile `json:"hostingEnvironmentProfile,omitempty"`
+ MicroService *string `json:"microService,omitempty"`
+ GatewaySiteName *string `json:"gatewaySiteName,omitempty"`
+ ClientAffinityEnabled *bool `json:"clientAffinityEnabled,omitempty"`
+ ClientCertEnabled *bool `json:"clientCertEnabled,omitempty"`
+ HostNamesDisabled *bool `json:"hostNamesDisabled,omitempty"`
+ OutboundIPAddresses *string `json:"outboundIpAddresses,omitempty"`
+ ContainerSize *int32 `json:"containerSize,omitempty"`
+ DailyMemoryTimeQuota *int32 `json:"dailyMemoryTimeQuota,omitempty"`
+ SuspendedTill *date.Time `json:"suspendedTill,omitempty"`
+ MaxNumberOfWorkers *int32 `json:"maxNumberOfWorkers,omitempty"`
+ CloningInfo *CloningInfo `json:"cloningInfo,omitempty"`
+ ResourceGroup *string `json:"resourceGroup,omitempty"`
+ IsDefaultContainer *bool `json:"isDefaultContainer,omitempty"`
+ DefaultHostName *string `json:"defaultHostName,omitempty"`
+ SlotSwapStatus *SlotSwapStatus `json:"slotSwapStatus,omitempty"`
+}
+
+// SiteAuthSettings is configuration settings for the Azure App Service
+// Authentication / Authorization feature.
+type SiteAuthSettings struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SiteAuthSettingsProperties `json:"properties,omitempty"`
+}
+
+// SiteAuthSettingsProperties is siteAuthSettings resource specific properties
+type SiteAuthSettingsProperties struct {
+ Enabled *bool `json:"enabled,omitempty"`
+ RuntimeVersion *string `json:"runtimeVersion,omitempty"`
+ UnauthenticatedClientAction UnauthenticatedClientAction `json:"unauthenticatedClientAction,omitempty"`
+ TokenStoreEnabled *bool `json:"tokenStoreEnabled,omitempty"`
+ AllowedExternalRedirectUrls *[]string `json:"allowedExternalRedirectUrls,omitempty"`
+ DefaultProvider BuiltInAuthenticationProvider `json:"defaultProvider,omitempty"`
+ TokenRefreshExtensionHours *float64 `json:"tokenRefreshExtensionHours,omitempty"`
+ ClientID *string `json:"clientId,omitempty"`
+ ClientSecret *string `json:"clientSecret,omitempty"`
+ Issuer *string `json:"issuer,omitempty"`
+ AllowedAudiences *[]string `json:"allowedAudiences,omitempty"`
+ AdditionalLoginParams *[]string `json:"additionalLoginParams,omitempty"`
+ GoogleClientID *string `json:"googleClientId,omitempty"`
+ GoogleClientSecret *string `json:"googleClientSecret,omitempty"`
+ GoogleOAuthScopes *[]string `json:"googleOAuthScopes,omitempty"`
+ FacebookAppID *string `json:"facebookAppId,omitempty"`
+ FacebookAppSecret *string `json:"facebookAppSecret,omitempty"`
+ FacebookOAuthScopes *[]string `json:"facebookOAuthScopes,omitempty"`
+ TwitterConsumerKey *string `json:"twitterConsumerKey,omitempty"`
+ TwitterConsumerSecret *string `json:"twitterConsumerSecret,omitempty"`
+ MicrosoftAccountClientID *string `json:"microsoftAccountClientId,omitempty"`
+ MicrosoftAccountClientSecret *string `json:"microsoftAccountClientSecret,omitempty"`
+ MicrosoftAccountOAuthScopes *[]string `json:"microsoftAccountOAuthScopes,omitempty"`
+}
+
+// SiteCloneability is represents whether or not an app is cloneable.
+type SiteCloneability struct {
+ autorest.Response `json:"-"`
+ Result CloneAbilityResult `json:"result,omitempty"`
+ BlockingFeatures *[]SiteCloneabilityCriterion `json:"blockingFeatures,omitempty"`
+ UnsupportedFeatures *[]SiteCloneabilityCriterion `json:"unsupportedFeatures,omitempty"`
+ BlockingCharacteristics *[]SiteCloneabilityCriterion `json:"blockingCharacteristics,omitempty"`
+}
+
+// SiteCloneabilityCriterion is an app cloneability criterion.
+type SiteCloneabilityCriterion struct {
+ Name *string `json:"name,omitempty"`
+ Description *string `json:"description,omitempty"`
+}
+
+// SiteConfig is configuration of an App Service app.
+type SiteConfig struct {
+ NumberOfWorkers *int32 `json:"numberOfWorkers,omitempty"`
+ DefaultDocuments *[]string `json:"defaultDocuments,omitempty"`
+ NetFrameworkVersion *string `json:"netFrameworkVersion,omitempty"`
+ PhpVersion *string `json:"phpVersion,omitempty"`
+ PythonVersion *string `json:"pythonVersion,omitempty"`
+ NodeVersion *string `json:"nodeVersion,omitempty"`
+ LinuxFxVersion *string `json:"linuxFxVersion,omitempty"`
+ RequestTracingEnabled *bool `json:"requestTracingEnabled,omitempty"`
+ RequestTracingExpirationTime *date.Time `json:"requestTracingExpirationTime,omitempty"`
+ RemoteDebuggingEnabled *bool `json:"remoteDebuggingEnabled,omitempty"`
+ RemoteDebuggingVersion *string `json:"remoteDebuggingVersion,omitempty"`
+ HTTPLoggingEnabled *bool `json:"httpLoggingEnabled,omitempty"`
+ LogsDirectorySizeLimit *int32 `json:"logsDirectorySizeLimit,omitempty"`
+ DetailedErrorLoggingEnabled *bool `json:"detailedErrorLoggingEnabled,omitempty"`
+ PublishingUsername *string `json:"publishingUsername,omitempty"`
+ AppSettings *[]NameValuePair `json:"appSettings,omitempty"`
+ ConnectionStrings *[]ConnStringInfo `json:"connectionStrings,omitempty"`
+ MachineKey *SiteMachineKey `json:"machineKey,omitempty"`
+ HandlerMappings *[]HandlerMapping `json:"handlerMappings,omitempty"`
+ DocumentRoot *string `json:"documentRoot,omitempty"`
+ ScmType ScmType `json:"scmType,omitempty"`
+ Use32BitWorkerProcess *bool `json:"use32BitWorkerProcess,omitempty"`
+ WebSocketsEnabled *bool `json:"webSocketsEnabled,omitempty"`
+ AlwaysOn *bool `json:"alwaysOn,omitempty"`
+ JavaVersion *string `json:"javaVersion,omitempty"`
+ JavaContainer *string `json:"javaContainer,omitempty"`
+ JavaContainerVersion *string `json:"javaContainerVersion,omitempty"`
+ AppCommandLine *string `json:"appCommandLine,omitempty"`
+ ManagedPipelineMode ManagedPipelineMode `json:"managedPipelineMode,omitempty"`
+ VirtualApplications *[]VirtualApplication `json:"virtualApplications,omitempty"`
+ LoadBalancing SiteLoadBalancing `json:"loadBalancing,omitempty"`
+ Experiments *Experiments `json:"experiments,omitempty"`
+ Limits *SiteLimits `json:"limits,omitempty"`
+ AutoHealEnabled *bool `json:"autoHealEnabled,omitempty"`
+ AutoHealRules *AutoHealRules `json:"autoHealRules,omitempty"`
+ TracingOptions *string `json:"tracingOptions,omitempty"`
+ VnetName *string `json:"vnetName,omitempty"`
+ Cors *CorsSettings `json:"cors,omitempty"`
+ Push *PushSettings `json:"push,omitempty"`
+ APIDefinition *APIDefinitionInfo `json:"apiDefinition,omitempty"`
+ AutoSwapSlotName *string `json:"autoSwapSlotName,omitempty"`
+ LocalMySQLEnabled *bool `json:"localMySqlEnabled,omitempty"`
+ IPSecurityRestrictions *[]IPSecurityRestriction `json:"ipSecurityRestrictions,omitempty"`
+}
+
+// SiteConfigResource is web app configuration ARM resource.
+type SiteConfigResource struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SiteConfig `json:"properties,omitempty"`
+}
+
+// SiteConfigResourceCollection is collection of site configurations.
+type SiteConfigResourceCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]SiteConfigResource `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SiteConfigResourceCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client SiteConfigResourceCollection) SiteConfigResourceCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// SiteConfigurationSnapshotInfo is a snapshot of a web app configuration.
+type SiteConfigurationSnapshotInfo struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SiteConfigurationSnapshotInfoProperties `json:"properties,omitempty"`
+}
+
+// SiteConfigurationSnapshotInfoProperties is siteConfigurationSnapshotInfo
+// resource specific properties
+type SiteConfigurationSnapshotInfoProperties struct {
+ Time *date.Time `json:"time,omitempty"`
+ ID *int32 `json:"id,omitempty"`
+}
+
+// SiteInstance is instance of an app.
+type SiteInstance struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SiteInstanceProperties `json:"properties,omitempty"`
+}
+
+// SiteInstanceProperties is siteInstance resource specific properties
+type SiteInstanceProperties struct {
+ Name *string `json:"name,omitempty"`
+}
+
+// SiteLimits is metric limits set on an app.
+type SiteLimits struct {
+ MaxPercentageCPU *float64 `json:"maxPercentageCpu,omitempty"`
+ MaxMemoryInMb *int64 `json:"maxMemoryInMb,omitempty"`
+ MaxDiskSizeInMb *int64 `json:"maxDiskSizeInMb,omitempty"`
+}
+
+// SiteLogsConfig is configuration of App Service site logs.
+type SiteLogsConfig struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SiteLogsConfigProperties `json:"properties,omitempty"`
+}
+
+// SiteLogsConfigProperties is siteLogsConfig resource specific properties
+type SiteLogsConfigProperties struct {
+ ApplicationLogs *ApplicationLogsConfig `json:"applicationLogs,omitempty"`
+ HTTPLogs *HTTPLogsConfig `json:"httpLogs,omitempty"`
+ FailedRequestsTracing *EnabledConfig `json:"failedRequestsTracing,omitempty"`
+ DetailedErrorMessages *EnabledConfig `json:"detailedErrorMessages,omitempty"`
+}
+
+// SiteMachineKey is machineKey of an app.
+type SiteMachineKey struct {
+ Validation *string `json:"validation,omitempty"`
+ ValidationKey *string `json:"validationKey,omitempty"`
+ Decryption *string `json:"decryption,omitempty"`
+ DecryptionKey *string `json:"decryptionKey,omitempty"`
+}
+
+// SitePhpErrorLogFlag is used for getting PHP error logging flag.
+type SitePhpErrorLogFlag struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SitePhpErrorLogFlagProperties `json:"properties,omitempty"`
+}
+
+// SitePhpErrorLogFlagProperties is sitePhpErrorLogFlag resource specific
+// properties
+type SitePhpErrorLogFlagProperties struct {
+ LocalLogErrors *string `json:"localLogErrors,omitempty"`
+ MasterLogErrors *string `json:"masterLogErrors,omitempty"`
+ LocalLogErrorsMaxLength *string `json:"localLogErrorsMaxLength,omitempty"`
+ MasterLogErrorsMaxLength *string `json:"masterLogErrorsMaxLength,omitempty"`
+}
+
+// SiteSeal is site seal
+type SiteSeal struct {
+ autorest.Response `json:"-"`
+ *string `json:"html,omitempty"`
+}
+
+// SiteSealRequest is site seal request.
+type SiteSealRequest struct {
+ LightTheme *bool `json:"lightTheme,omitempty"`
+ Locale *string `json:"locale,omitempty"`
+}
+
+// SiteSourceControl is source control configuration for an app.
+type SiteSourceControl struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SiteSourceControlProperties `json:"properties,omitempty"`
+}
+
+// SiteSourceControlProperties is siteSourceControl resource specific
+// properties
+type SiteSourceControlProperties struct {
+ RepoURL *string `json:"repoUrl,omitempty"`
+ Branch *string `json:"branch,omitempty"`
+ IsManualIntegration *bool `json:"isManualIntegration,omitempty"`
+ DeploymentRollbackEnabled *bool `json:"deploymentRollbackEnabled,omitempty"`
+ IsMercurial *bool `json:"isMercurial,omitempty"`
+}
+
+// SkuCapacity is description of the App Service plan scale options.
+type SkuCapacity struct {
+ Minimum *int32 `json:"minimum,omitempty"`
+ Maximum *int32 `json:"maximum,omitempty"`
+ Default *int32 `json:"default,omitempty"`
+ ScaleType *string `json:"scaleType,omitempty"`
+}
+
+// SkuDescription is description of a SKU for a scalable resource.
+type SkuDescription struct {
+ Name *string `json:"name,omitempty"`
+ Tier *string `json:"tier,omitempty"`
+ Size *string `json:"size,omitempty"`
+ Family *string `json:"family,omitempty"`
+ Capacity *int32 `json:"capacity,omitempty"`
+ SkuCapacity *SkuCapacity `json:"skuCapacity,omitempty"`
+ Locations *[]string `json:"locations,omitempty"`
+ Capabilities *[]Capability `json:"capabilities,omitempty"`
+}
+
+// SkuInfo is sKU discovery information.
+type SkuInfo struct {
+ ResourceType *string `json:"resourceType,omitempty"`
+ Sku *SkuDescription `json:"sku,omitempty"`
+ Capacity *SkuCapacity `json:"capacity,omitempty"`
+}
+
+// SkuInfoCollection is collection of SKU information.
+type SkuInfoCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]SkuInfo `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SkuInfoCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client SkuInfoCollection) SkuInfoCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// SkuInfos is collection of SKU information.
+type SkuInfos struct {
+ autorest.Response `json:"-"`
+ ResourceType *string `json:"resourceType,omitempty"`
+ Skus *[]GlobalCsmSkuDescription `json:"skus,omitempty"`
+}
+
+// SlotConfigNames is names for connection strings and application settings to
+// be marked as sticky to the deployment slot and not moved during a swap
+// operation.
+// This is valid for all deployment slots in an app.
+type SlotConfigNames struct {
+ ConnectionStringNames *[]string `json:"connectionStringNames,omitempty"`
+ AppSettingNames *[]string `json:"appSettingNames,omitempty"`
+}
+
+// SlotConfigNamesResource is slot Config names azure resource.
+type SlotConfigNamesResource struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SlotConfigNames `json:"properties,omitempty"`
+}
+
+// SlotDifference is a setting difference between two deployment slots of an
+// app.
+type SlotDifference struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SlotDifferenceProperties `json:"properties,omitempty"`
+}
+
+// SlotDifferenceProperties is slotDifference resource specific properties
+type SlotDifferenceProperties struct {
+ Type *string `json:"type,omitempty"`
+ SettingType *string `json:"settingType,omitempty"`
+ DiffRule *string `json:"diffRule,omitempty"`
+ SettingName *string `json:"settingName,omitempty"`
+ ValueInCurrentSlot *string `json:"valueInCurrentSlot,omitempty"`
+ ValueInTargetSlot *string `json:"valueInTargetSlot,omitempty"`
+ Description *string `json:"description,omitempty"`
+}
+
+// SlotDifferenceCollection is collection of slot differences.
+type SlotDifferenceCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]SlotDifference `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SlotDifferenceCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client SlotDifferenceCollection) SlotDifferenceCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// SlotSwapStatus is the status of the last successfull slot swap operation.
+type SlotSwapStatus struct {
+ TimestampUtc *date.Time `json:"timestampUtc,omitempty"`
+ SourceSlotName *string `json:"sourceSlotName,omitempty"`
+ DestinationSlotName *string `json:"destinationSlotName,omitempty"`
+}
+
+// SlowRequestsBasedTrigger is trigger based on request execution time.
+type SlowRequestsBasedTrigger struct {
+ TimeTaken *string `json:"timeTaken,omitempty"`
+ Count *int32 `json:"count,omitempty"`
+ TimeInterval *string `json:"timeInterval,omitempty"`
+}
+
+// Snapshot is a snapshot of an app.
+type Snapshot struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SnapshotProperties `json:"properties,omitempty"`
+}
+
+// SnapshotProperties is snapshot resource specific properties
+type SnapshotProperties struct {
+ Time *date.Time `json:"time,omitempty"`
+}
+
+// SnapshotCollection is collection of snapshots which can be used to revert an
+// app to a previous time.
+type SnapshotCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]Snapshot `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SnapshotCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client SnapshotCollection) SnapshotCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// SourceControl is the source control OAuth token.
+type SourceControl struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *SourceControlProperties `json:"properties,omitempty"`
+}
+
+// SourceControlProperties is sourceControl resource specific properties
+type SourceControlProperties struct {
+ Name *string `json:"name,omitempty"`
+ Token *string `json:"token,omitempty"`
+ TokenSecret *string `json:"tokenSecret,omitempty"`
+ RefreshToken *string `json:"refreshToken,omitempty"`
+ ExpirationTime *date.Time `json:"expirationTime,omitempty"`
+}
+
+// SourceControlCollection is collection of source controls.
+type SourceControlCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]SourceControl `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// SourceControlCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client SourceControlCollection) SourceControlCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// StampCapacity is stamp capacity information.
+type StampCapacity struct {
+ Name *string `json:"name,omitempty"`
+ AvailableCapacity *int64 `json:"availableCapacity,omitempty"`
+ TotalCapacity *int64 `json:"totalCapacity,omitempty"`
+ Unit *string `json:"unit,omitempty"`
+ ComputeMode ComputeModeOptions `json:"computeMode,omitempty"`
+ WorkerSize WorkerSizeOptions `json:"workerSize,omitempty"`
+ WorkerSizeID *int32 `json:"workerSizeId,omitempty"`
+ ExcludeFromCapacityAllocation *bool `json:"excludeFromCapacityAllocation,omitempty"`
+ IsApplicableForAllComputeModes *bool `json:"isApplicableForAllComputeModes,omitempty"`
+ SiteMode *string `json:"siteMode,omitempty"`
+}
+
+// StampCapacityCollection is collection of stamp capacities.
+type StampCapacityCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]StampCapacity `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// StampCapacityCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client StampCapacityCollection) StampCapacityCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// StatusCodesBasedTrigger is trigger based on status code.
+type StatusCodesBasedTrigger struct {
+ Status *int32 `json:"status,omitempty"`
+ SubStatus *int32 `json:"subStatus,omitempty"`
+ Win32Status *int32 `json:"win32Status,omitempty"`
+ Count *int32 `json:"count,omitempty"`
+ TimeInterval *string `json:"timeInterval,omitempty"`
+}
+
+// StorageMigrationOptions is options for app content migration.
+type StorageMigrationOptions struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *StorageMigrationOptionsProperties `json:"properties,omitempty"`
+}
+
+// StorageMigrationOptionsProperties is storageMigrationOptions resource
+// specific properties
+type StorageMigrationOptionsProperties struct {
+ AzurefilesConnectionString *string `json:"azurefilesConnectionString,omitempty"`
+ AzurefilesShare *string `json:"azurefilesShare,omitempty"`
+ SwitchSiteAfterMigration *bool `json:"switchSiteAfterMigration,omitempty"`
+ BlockWriteAccessToSite *bool `json:"blockWriteAccessToSite,omitempty"`
+}
+
+// StorageMigrationResponse is response for a migration of app content request.
+type StorageMigrationResponse struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *StorageMigrationResponseProperties `json:"properties,omitempty"`
+}
+
+// StorageMigrationResponseProperties is storageMigrationResponse resource
+// specific properties
+type StorageMigrationResponseProperties struct {
+ OperationID *string `json:"operationId,omitempty"`
+}
+
+// String is
+type String struct {
+ autorest.Response `json:"-"`
+ Value *string `json:"value,omitempty"`
+}
+
+// StringDictionary is string dictionary resource.
+type StringDictionary struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ Properties *map[string]*string `json:"properties,omitempty"`
+}
+
+// TldLegalAgreement is legal agreement for a top level domain.
+type TldLegalAgreement struct {
+ AgreementKey *string `json:"agreementKey,omitempty"`
+ Title *string `json:"title,omitempty"`
+ Content *string `json:"content,omitempty"`
+ URL *string `json:"url,omitempty"`
+}
+
+// TldLegalAgreementCollection is collection of top-level domain legal
+// agreements.
+type TldLegalAgreementCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]TldLegalAgreement `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// TldLegalAgreementCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client TldLegalAgreementCollection) TldLegalAgreementCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// TopLevelDomain is a top level domain object.
+type TopLevelDomain struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *TopLevelDomainProperties `json:"properties,omitempty"`
+}
+
+// TopLevelDomainProperties is topLevelDomain resource specific properties
+type TopLevelDomainProperties struct {
+ DomainName *string `json:"name,omitempty"`
+ Privacy *bool `json:"privacy,omitempty"`
+}
+
+// TopLevelDomainAgreementOption is options for retrieving the list of top
+// level domain legal agreements.
+type TopLevelDomainAgreementOption struct {
+ IncludePrivacy *bool `json:"includePrivacy,omitempty"`
+ ForTransfer *bool `json:"forTransfer,omitempty"`
+}
+
+// TopLevelDomainCollection is collection of Top-level domains.
+type TopLevelDomainCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]TopLevelDomain `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// TopLevelDomainCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client TopLevelDomainCollection) TopLevelDomainCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// Usage is usage of the quota resource.
+type Usage struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *UsageProperties `json:"properties,omitempty"`
+}
+
+// UsageProperties is usage resource specific properties
+type UsageProperties struct {
+ DisplayName *string `json:"displayName,omitempty"`
+ Name *string `json:"name,omitempty"`
+ ResourceName *string `json:"resourceName,omitempty"`
+ Unit *string `json:"unit,omitempty"`
+ CurrentValue *int64 `json:"currentValue,omitempty"`
+ Limit *int64 `json:"limit,omitempty"`
+ NextResetTime *date.Time `json:"nextResetTime,omitempty"`
+ ComputeMode ComputeModeOptions `json:"computeMode,omitempty"`
+ SiteMode *string `json:"siteMode,omitempty"`
+}
+
+// UsageCollection is collection of usages.
+type UsageCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]Usage `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// UsageCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client UsageCollection) UsageCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// User is user crendentials used for publishing activity.
+type User struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *UserProperties `json:"properties,omitempty"`
+}
+
+// UserProperties is user resource specific properties
+type UserProperties struct {
+ UserName *string `json:"name,omitempty"`
+ PublishingUserName *string `json:"publishingUserName,omitempty"`
+ PublishingPassword *string `json:"publishingPassword,omitempty"`
+ PublishingPasswordHash *string `json:"publishingPasswordHash,omitempty"`
+ PublishingPasswordHashSalt *string `json:"publishingPasswordHashSalt,omitempty"`
+}
+
+// ValidateProperties is app properties used for validation.
+type ValidateProperties struct {
+ ServerFarmID *string `json:"serverFarmId,omitempty"`
+ SkuName *string `json:"skuName,omitempty"`
+ NeedLinuxWorkers *bool `json:"needLinuxWorkers,omitempty"`
+ Capacity *int32 `json:"capacity,omitempty"`
+ HostingEnvironment *string `json:"hostingEnvironment,omitempty"`
+}
+
+// ValidateRequest is resource validation request content.
+type ValidateRequest struct {
+ Name *string `json:"name,omitempty"`
+ Type ValidateResourceTypes `json:"type,omitempty"`
+ Location *string `json:"location,omitempty"`
+ *ValidateProperties `json:"properties,omitempty"`
+}
+
+// ValidateResponse is describes the result of resource validation.
+type ValidateResponse struct {
+ autorest.Response `json:"-"`
+ Status *string `json:"status,omitempty"`
+ Error *ValidateResponseError `json:"error,omitempty"`
+}
+
+// ValidateResponseError is error details for when validation fails.
+type ValidateResponseError struct {
+ Code *string `json:"code,omitempty"`
+ Message *string `json:"message,omitempty"`
+}
+
+// VirtualApplication is virtual application in an app.
+type VirtualApplication struct {
+ VirtualPath *string `json:"virtualPath,omitempty"`
+ PhysicalPath *string `json:"physicalPath,omitempty"`
+ PreloadEnabled *bool `json:"preloadEnabled,omitempty"`
+ VirtualDirectories *[]VirtualDirectory `json:"virtualDirectories,omitempty"`
+}
+
+// VirtualDirectory is directory for virtual application.
+type VirtualDirectory struct {
+ VirtualPath *string `json:"virtualPath,omitempty"`
+ PhysicalPath *string `json:"physicalPath,omitempty"`
+}
+
+// VirtualIPMapping is virtual IP mapping.
+type VirtualIPMapping struct {
+ VirtualIP *string `json:"virtualIP,omitempty"`
+ InternalHTTPPort *int32 `json:"internalHttpPort,omitempty"`
+ InternalHTTPSPort *int32 `json:"internalHttpsPort,omitempty"`
+ InUse *bool `json:"inUse,omitempty"`
+}
+
+// VirtualNetworkProfile is specification for using a Virtual Network.
+type VirtualNetworkProfile struct {
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Subnet *string `json:"subnet,omitempty"`
+}
+
+// VnetGateway is the Virtual Network gateway contract. This is used to give
+// the Virtual Network gateway access to the VPN package.
+type VnetGateway struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *VnetGatewayProperties `json:"properties,omitempty"`
+}
+
+// VnetGatewayProperties is vnetGateway resource specific properties
+type VnetGatewayProperties struct {
+ VnetName *string `json:"vnetName,omitempty"`
+ VpnPackageURI *string `json:"vpnPackageUri,omitempty"`
+}
+
+// VnetInfo is virtual Network information contract.
+type VnetInfo struct {
+ autorest.Response `json:"-"`
+ VnetResourceID *string `json:"vnetResourceId,omitempty"`
+ CertThumbprint *string `json:"certThumbprint,omitempty"`
+ CertBlob *string `json:"certBlob,omitempty"`
+ Routes *[]VnetRoute `json:"routes,omitempty"`
+ ResyncRequired *bool `json:"resyncRequired,omitempty"`
+ DNSServers *string `json:"dnsServers,omitempty"`
+}
+
+// VnetRoute is virtual Network route contract used to pass routing information
+// for a Virtual Network.
+type VnetRoute struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *VnetRouteProperties `json:"properties,omitempty"`
+}
+
+// VnetRouteProperties is vnetRoute resource specific properties
+type VnetRouteProperties struct {
+ VnetRouteName *string `json:"name,omitempty"`
+ StartAddress *string `json:"startAddress,omitempty"`
+ EndAddress *string `json:"endAddress,omitempty"`
+ RouteType RouteType `json:"routeType,omitempty"`
+}
+
+// WorkerPool is worker pool of an App Service Environment.
+type WorkerPool struct {
+ WorkerSizeID *int32 `json:"workerSizeId,omitempty"`
+ ComputeMode ComputeModeOptions `json:"computeMode,omitempty"`
+ WorkerSize *string `json:"workerSize,omitempty"`
+ WorkerCount *int32 `json:"workerCount,omitempty"`
+ InstanceNames *[]string `json:"instanceNames,omitempty"`
+}
+
+// WorkerPoolCollection is collection of worker pools.
+type WorkerPoolCollection struct {
+ autorest.Response `json:"-"`
+ Value *[]WorkerPoolResource `json:"value,omitempty"`
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// WorkerPoolCollectionPreparer prepares a request to retrieve the next set of results. It returns
+// nil if no more results exist.
+func (client WorkerPoolCollection) WorkerPoolCollectionPreparer() (*http.Request, error) {
+ if client.NextLink == nil || len(to.String(client.NextLink)) <= 0 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(client.NextLink)))
+}
+
+// WorkerPoolResource is worker pool of an App Service Environment ARM
+// resource.
+type WorkerPoolResource struct {
+ autorest.Response `json:"-"`
+ ID *string `json:"id,omitempty"`
+ Name *string `json:"name,omitempty"`
+ Kind *string `json:"kind,omitempty"`
+ Location *string `json:"location,omitempty"`
+ Type *string `json:"type,omitempty"`
+ Tags *map[string]*string `json:"tags,omitempty"`
+ *WorkerPool `json:"properties,omitempty"`
+ Sku *SkuDescription `json:"sku,omitempty"`
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/provider.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/provider.go
new file mode 100755
index 000000000000..b2c75d21f3a2
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/provider.go
@@ -0,0 +1,160 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "net/http"
+)
+
+// ProviderClient is the composite Swagger for WebSite Management Client
+type ProviderClient struct {
+ ManagementClient
+}
+
+// NewProviderClient creates an instance of the ProviderClient client.
+func NewProviderClient(subscriptionID string) ProviderClient {
+ return NewProviderClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewProviderClientWithBaseURI creates an instance of the ProviderClient
+// client.
+func NewProviderClientWithBaseURI(baseURI string, subscriptionID string) ProviderClient {
+ return ProviderClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// GetAvailableStacks get available application frameworks and their versions
+func (client ProviderClient) GetAvailableStacks() (result SetObject, err error) {
+ req, err := client.GetAvailableStacksPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetAvailableStacks", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetAvailableStacksSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetAvailableStacks", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetAvailableStacksResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetAvailableStacks", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetAvailableStacksPreparer prepares the GetAvailableStacks request.
+func (client ProviderClient) GetAvailableStacksPreparer() (*http.Request, error) {
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Web/availableStacks"),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetAvailableStacksSender sends the GetAvailableStacks request. The method will close the
+// http.Response Body if it receives an error.
+func (client ProviderClient) GetAvailableStacksSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetAvailableStacksResponder handles the response to the GetAvailableStacks request. The method always
+// closes the http.Response Body.
+func (client ProviderClient) GetAvailableStacksResponder(resp *http.Response) (result SetObject, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetAvailableStacksOnPrem get available application frameworks and their
+// versions
+func (client ProviderClient) GetAvailableStacksOnPrem() (result SetObject, err error) {
+ req, err := client.GetAvailableStacksOnPremPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetAvailableStacksOnPrem", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetAvailableStacksOnPremSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetAvailableStacksOnPrem", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetAvailableStacksOnPremResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetAvailableStacksOnPrem", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetAvailableStacksOnPremPreparer prepares the GetAvailableStacksOnPrem request.
+func (client ProviderClient) GetAvailableStacksOnPremPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/availableStacks", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetAvailableStacksOnPremSender sends the GetAvailableStacksOnPrem request. The method will close the
+// http.Response Body if it receives an error.
+func (client ProviderClient) GetAvailableStacksOnPremSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetAvailableStacksOnPremResponder handles the response to the GetAvailableStacksOnPrem request. The method always
+// closes the http.Response Body.
+func (client ProviderClient) GetAvailableStacksOnPremResponder(resp *http.Response) (result SetObject, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/recommendations.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/recommendations.go
new file mode 100755
index 000000000000..3cd70e2f8891
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/recommendations.go
@@ -0,0 +1,570 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// RecommendationsClient is the composite Swagger for WebSite Management Client
+type RecommendationsClient struct {
+ ManagementClient
+}
+
+// NewRecommendationsClient creates an instance of the RecommendationsClient
+// client.
+func NewRecommendationsClient(subscriptionID string) RecommendationsClient {
+ return NewRecommendationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewRecommendationsClientWithBaseURI creates an instance of the
+// RecommendationsClient client.
+func NewRecommendationsClientWithBaseURI(baseURI string, subscriptionID string) RecommendationsClient {
+ return RecommendationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// DisableAllForWebApp disable all recommendations for an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. siteName is name of the app.
+func (client RecommendationsClient) DisableAllForWebApp(resourceGroupName string, siteName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.RecommendationsClient", "DisableAllForWebApp")
+ }
+
+ req, err := client.DisableAllForWebAppPreparer(resourceGroupName, siteName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableAllForWebApp", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DisableAllForWebAppSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableAllForWebApp", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DisableAllForWebAppResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableAllForWebApp", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DisableAllForWebAppPreparer prepares the DisableAllForWebApp request.
+func (client RecommendationsClient) DisableAllForWebAppPreparer(resourceGroupName string, siteName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "siteName": autorest.Encode("path", siteName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName}/recommendations/disable", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// DisableAllForWebAppSender sends the DisableAllForWebApp request. The method will close the
+// http.Response Body if it receives an error.
+func (client RecommendationsClient) DisableAllForWebAppSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// DisableAllForWebAppResponder handles the response to the DisableAllForWebApp request. The method always
+// closes the http.Response Body.
+func (client RecommendationsClient) DisableAllForWebAppResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// GetRuleDetailsByWebApp get a recommendation rule for an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. siteName is name of the app. name is name of the recommendation.
+// updateSeen is specify true to update the last-seen timestamp of
+// the recommendation object.
+func (client RecommendationsClient) GetRuleDetailsByWebApp(resourceGroupName string, siteName string, name string, updateSeen *bool) (result RecommendationRule, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.RecommendationsClient", "GetRuleDetailsByWebApp")
+ }
+
+ req, err := client.GetRuleDetailsByWebAppPreparer(resourceGroupName, siteName, name, updateSeen)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRuleDetailsByWebApp", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetRuleDetailsByWebAppSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRuleDetailsByWebApp", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetRuleDetailsByWebAppResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRuleDetailsByWebApp", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetRuleDetailsByWebAppPreparer prepares the GetRuleDetailsByWebApp request.
+func (client RecommendationsClient) GetRuleDetailsByWebAppPreparer(resourceGroupName string, siteName string, name string, updateSeen *bool) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "siteName": autorest.Encode("path", siteName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if updateSeen != nil {
+ queryParameters["updateSeen"] = autorest.Encode("query", *updateSeen)
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName}/recommendations/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetRuleDetailsByWebAppSender sends the GetRuleDetailsByWebApp request. The method will close the
+// http.Response Body if it receives an error.
+func (client RecommendationsClient) GetRuleDetailsByWebAppSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetRuleDetailsByWebAppResponder handles the response to the GetRuleDetailsByWebApp request. The method always
+// closes the http.Response Body.
+func (client RecommendationsClient) GetRuleDetailsByWebAppResponder(resp *http.Response) (result RecommendationRule, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List list all recommendations for a subscription.
+//
+// featured is specify true to return only the most critical
+// recommendations. The default is false, which returns all
+// recommendations. filter is filter is specified by using OData syntax.
+// Example: $filter=channels eq 'Api' or channel eq 'Notification' and
+// startTime eq '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z'
+// and timeGrain eq duration'[PT1H|PT1M|P1D]
+func (client RecommendationsClient) List(featured *bool, filter string) (result ListRecommendation, err error) {
+ req, err := client.ListPreparer(featured, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client RecommendationsClient) ListPreparer(featured *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if featured != nil {
+ queryParameters["featured"] = autorest.Encode("query", *featured)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/recommendations", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client RecommendationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client RecommendationsClient) ListResponder(resp *http.Response) (result ListRecommendation, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListHistoryForWebApp get past recommendations for an app, optionally
+// specified by the time range.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. siteName is name of the app. filter is filter is specified by using
+// OData syntax. Example: $filter=channels eq 'Api' or channel eq
+// 'Notification' and startTime eq '2014-01-01T00:00:00Z' and endTime eq
+// '2014-12-31T23:59:59Z' and timeGrain eq duration'[PT1H|PT1M|P1D]
+func (client RecommendationsClient) ListHistoryForWebApp(resourceGroupName string, siteName string, filter string) (result ListRecommendation, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.RecommendationsClient", "ListHistoryForWebApp")
+ }
+
+ req, err := client.ListHistoryForWebAppPreparer(resourceGroupName, siteName, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListHistoryForWebApp", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListHistoryForWebAppSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListHistoryForWebApp", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListHistoryForWebAppResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListHistoryForWebApp", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListHistoryForWebAppPreparer prepares the ListHistoryForWebApp request.
+func (client RecommendationsClient) ListHistoryForWebAppPreparer(resourceGroupName string, siteName string, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "siteName": autorest.Encode("path", siteName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName}/recommendationHistory", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListHistoryForWebAppSender sends the ListHistoryForWebApp request. The method will close the
+// http.Response Body if it receives an error.
+func (client RecommendationsClient) ListHistoryForWebAppSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListHistoryForWebAppResponder handles the response to the ListHistoryForWebApp request. The method always
+// closes the http.Response Body.
+func (client RecommendationsClient) ListHistoryForWebAppResponder(resp *http.Response) (result ListRecommendation, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListRecommendedRulesForWebApp get all recommendations for an app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. siteName is name of the app. featured is specify true
+// to return only the most critical recommendations. The default is
+// false, which returns all recommendations. filter is return only
+// channels specified in the filter. Filter is specified by using OData syntax.
+// Example: $filter=channels eq 'Api' or channel eq 'Notification'
+func (client RecommendationsClient) ListRecommendedRulesForWebApp(resourceGroupName string, siteName string, featured *bool, filter string) (result ListRecommendation, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.RecommendationsClient", "ListRecommendedRulesForWebApp")
+ }
+
+ req, err := client.ListRecommendedRulesForWebAppPreparer(resourceGroupName, siteName, featured, filter)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListRecommendedRulesForWebApp", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListRecommendedRulesForWebAppSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListRecommendedRulesForWebApp", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListRecommendedRulesForWebAppResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListRecommendedRulesForWebApp", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListRecommendedRulesForWebAppPreparer prepares the ListRecommendedRulesForWebApp request.
+func (client RecommendationsClient) ListRecommendedRulesForWebAppPreparer(resourceGroupName string, siteName string, featured *bool, filter string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "siteName": autorest.Encode("path", siteName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+ if featured != nil {
+ queryParameters["featured"] = autorest.Encode("query", *featured)
+ }
+ if len(filter) > 0 {
+ queryParameters["$filter"] = filter
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName}/recommendations", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListRecommendedRulesForWebAppSender sends the ListRecommendedRulesForWebApp request. The method will close the
+// http.Response Body if it receives an error.
+func (client RecommendationsClient) ListRecommendedRulesForWebAppSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListRecommendedRulesForWebAppResponder handles the response to the ListRecommendedRulesForWebApp request. The method always
+// closes the http.Response Body.
+func (client RecommendationsClient) ListRecommendedRulesForWebAppResponder(resp *http.Response) (result ListRecommendation, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result.Value),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ResetAllFilters reset all recommendation opt-out settings for a
+// subscription.
+func (client RecommendationsClient) ResetAllFilters() (result autorest.Response, err error) {
+ req, err := client.ResetAllFiltersPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ResetAllFilters", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ResetAllFiltersSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ResetAllFilters", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ResetAllFiltersResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ResetAllFilters", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ResetAllFiltersPreparer prepares the ResetAllFilters request.
+func (client RecommendationsClient) ResetAllFiltersPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/recommendations/reset", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ResetAllFiltersSender sends the ResetAllFilters request. The method will close the
+// http.Response Body if it receives an error.
+func (client RecommendationsClient) ResetAllFiltersSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ResetAllFiltersResponder handles the response to the ResetAllFilters request. The method always
+// closes the http.Response Body.
+func (client RecommendationsClient) ResetAllFiltersResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// ResetAllFiltersForWebApp reset all recommendation opt-out settings for an
+// app.
+//
+// resourceGroupName is name of the resource group to which the resource
+// belongs. siteName is name of the app.
+func (client RecommendationsClient) ResetAllFiltersForWebApp(resourceGroupName string, siteName string) (result autorest.Response, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewErrorWithValidationError(err, "web.RecommendationsClient", "ResetAllFiltersForWebApp")
+ }
+
+ req, err := client.ResetAllFiltersForWebAppPreparer(resourceGroupName, siteName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ResetAllFiltersForWebApp", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ResetAllFiltersForWebAppSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ResetAllFiltersForWebApp", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ResetAllFiltersForWebAppResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ResetAllFiltersForWebApp", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ResetAllFiltersForWebAppPreparer prepares the ResetAllFiltersForWebApp request.
+func (client RecommendationsClient) ResetAllFiltersForWebAppPreparer(resourceGroupName string, siteName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "siteName": autorest.Encode("path", siteName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName}/recommendations/reset", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ResetAllFiltersForWebAppSender sends the ResetAllFiltersForWebApp request. The method will close the
+// http.Response Body if it receives an error.
+func (client RecommendationsClient) ResetAllFiltersForWebAppSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ResetAllFiltersForWebAppResponder handles the response to the ResetAllFiltersForWebApp request. The method always
+// closes the http.Response Body.
+func (client RecommendationsClient) ResetAllFiltersForWebAppResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/topleveldomains.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/topleveldomains.go
new file mode 100755
index 000000000000..ea9b2ff91bda
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/topleveldomains.go
@@ -0,0 +1,283 @@
+package web
+
+// 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 1.0.1.0
+// Changes may cause incorrect behavior and will be lost if the code is
+// regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "net/http"
+)
+
+// TopLevelDomainsClient is the composite Swagger for WebSite Management Client
+type TopLevelDomainsClient struct {
+ ManagementClient
+}
+
+// NewTopLevelDomainsClient creates an instance of the TopLevelDomainsClient
+// client.
+func NewTopLevelDomainsClient(subscriptionID string) TopLevelDomainsClient {
+ return NewTopLevelDomainsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewTopLevelDomainsClientWithBaseURI creates an instance of the
+// TopLevelDomainsClient client.
+func NewTopLevelDomainsClientWithBaseURI(baseURI string, subscriptionID string) TopLevelDomainsClient {
+ return TopLevelDomainsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// Get get details of a top-level domain.
+//
+// name is name of the top-level domain.
+func (client TopLevelDomainsClient) Get(name string) (result TopLevelDomain, err error) {
+ req, err := client.GetPreparer(name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client TopLevelDomainsClient) GetPreparer(name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/topLevelDomains/{name}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client TopLevelDomainsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client TopLevelDomainsClient) GetResponder(resp *http.Response) (result TopLevelDomain, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List get all top-level domains supported for registration.
+func (client TopLevelDomainsClient) List() (result TopLevelDomainCollection, err error) {
+ req, err := client.ListPreparer()
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client TopLevelDomainsClient) ListPreparer() (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/topLevelDomains", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client TopLevelDomainsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client TopLevelDomainsClient) ListResponder(resp *http.Response) (result TopLevelDomainCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ 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 TopLevelDomainsClient) ListNextResults(lastResults TopLevelDomainCollection) (result TopLevelDomainCollection, err error) {
+ req, err := lastResults.TopLevelDomainCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "List", 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, "web.TopLevelDomainsClient", "List", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "List", resp, "Failure responding to next results request")
+ }
+
+ return
+}
+
+// ListAgreements gets all legal agreements that user needs to accept before
+// purchasing a domain.
+//
+// name is name of the top-level domain. agreementOption is domain agreement
+// options.
+func (client TopLevelDomainsClient) ListAgreements(name string, agreementOption TopLevelDomainAgreementOption) (result TldLegalAgreementCollection, err error) {
+ req, err := client.ListAgreementsPreparer(name, agreementOption)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListAgreements", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAgreementsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListAgreements", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListAgreementsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListAgreements", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListAgreementsPreparer prepares the ListAgreements request.
+func (client TopLevelDomainsClient) ListAgreementsPreparer(name string, agreementOption TopLevelDomainAgreementOption) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2015-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsJSON(),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/topLevelDomains/{name}/listAgreements", pathParameters),
+ autorest.WithJSON(agreementOption),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare(&http.Request{})
+}
+
+// ListAgreementsSender sends the ListAgreements request. The method will close the
+// http.Response Body if it receives an error.
+func (client TopLevelDomainsClient) ListAgreementsSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req)
+}
+
+// ListAgreementsResponder handles the response to the ListAgreements request. The method always
+// closes the http.Response Body.
+func (client TopLevelDomainsClient) ListAgreementsResponder(resp *http.Response) (result TldLegalAgreementCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAgreementsNextResults retrieves the next set of results, if any.
+func (client TopLevelDomainsClient) ListAgreementsNextResults(lastResults TldLegalAgreementCollection) (result TldLegalAgreementCollection, err error) {
+ req, err := lastResults.TldLegalAgreementCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListAgreements", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+
+ resp, err := client.ListAgreementsSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListAgreements", resp, "Failure sending next results request")
+ }
+
+ result, err = client.ListAgreementsResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListAgreements", resp, "Failure responding to next results request")
+ }
+
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/arm/web/version.go b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/version.go
new file mode 100755
index 000000000000..ec83bd3880d0
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/arm/web/version.go
@@ -0,0 +1,28 @@
+package web
+
+// 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 1.2.2.0
+// 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/v10.3.0-beta arm-web/"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+ return "v10.3.0-beta"
+}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index ab848eba6943..c70837985090 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -170,6 +170,14 @@
"version": "=v10.3.0-beta",
"versionExact": "v10.3.0-beta"
},
+ {
+ "checksumSHA1": "PBefmgCVsIElMuypHfMgBBFiEZQ=",
+ "path": "github.com/Azure/azure-sdk-for-go/arm/web",
+ "revision": "57db66900881e9fd21fd041a9d013514700ecab3",
+ "revisionTime": "2017-08-18T20:19:01Z",
+ "version": "=v10.3.0-beta",
+ "versionExact": "v10.3.0-beta"
+ },
{
"checksumSHA1": "KWdWO4eMy7/x85pgQhngfaTiqz8=",
"path": "github.com/Azure/azure-sdk-for-go/storage",
diff --git a/website/azurerm.erb b/website/azurerm.erb
index 35aa2223722d..e39393b05092 100644
--- a/website/azurerm.erb
+++ b/website/azurerm.erb
@@ -42,6 +42,17 @@
+ >
+ App Service (Web Apps) Resources
+
+
+
>
Application Insights Resources
diff --git a/website/docs/r/app_service_plan.html.markdown b/website/docs/r/app_service_plan.html.markdown
new file mode 100644
index 000000000000..49bff71ca26c
--- /dev/null
+++ b/website/docs/r/app_service_plan.html.markdown
@@ -0,0 +1,78 @@
+---
+layout: "azurerm"
+page_title: "Azure Resource Manager: azurerm_app_service_plan"
+sidebar_current: "docs-azurerm-resource-app_service_plan"
+description: |-
+ Create an App Service Plan component.
+---
+
+# azurerm\_app\_service\_plan
+
+Create an App Service Plan component.
+
+## Example Usage
+
+```hcl
+resource "azurerm_resource_group" "test" {
+ name = "api-rg-pro"
+ location = "West Europe"
+}
+
+resource "azurerm_app_service_plan" "test" {
+ name = "api-appserviceplan-pro"
+ location = "West Europe"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ tier = "Standard"
+ size = "S1"
+ }
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `name` - (Required) Specifies the name of the App Service Plan component. Changing this forces a new resource to be created.
+
+* `resource_group_name` - (Required) The name of the resource group in which to create the App Service Plan component.
+
+* `location` - (Required) Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created.
+
+* `sku` - (Required) A `sku` block as documented below.
+
+* `properties` - (Optional) A `properties` block as documented below.
+
+* `tags` - (Optional) A mapping of tags to assign to the resource.
+
+`sku` supports the following:
+
+* `tier` - (Required) Specifies the plan's pricing tier.
+
+* `size` - (Required) Specifies the plan's instance size.
+
+* `capacity` - (Optional) Specifies the number of workers associated with this App Service Plan.
+
+`properties` supports the following:
+
+* `maximum_number_of_workers` - (Optional) Maximum number of instances that can be assigned to this App Service plan.
+
+* `reserved` - (Optional) Is this App Service Plan `Reserved`. Defaults to `false`.
+
+* `per_site_scaling` - (Optional) Can Apps assigned to this App Service Plan be scaled independently? If set to `false` apps assigned to this plan will scale to all instances of the plan. Defaults to `false`.
+
+## Attributes Reference
+
+The following attributes are exported:
+
+* `id` - The ID of the App Service Plan component.
+* `maximum_number_of_workers` - The maximum number of workers supported with the App Service Plan's sku.
+
+## Import
+
+App Service Plan instances can be imported using the `resource id`, e.g.
+
+```
+terraform import azurerm_app_service_plan.instance1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Web/serverfarms/instance1
+```