diff --git a/azurerm/config.go b/azurerm/config.go
index 06c646de77c9..5f75ec675f25 100644
--- a/azurerm/config.go
+++ b/azurerm/config.go
@@ -34,6 +34,7 @@ import (
"github.com/Azure/azure-sdk-for-go/services/postgresql/mgmt/2017-04-30-preview/postgresql"
"github.com/Azure/azure-sdk-for-go/services/recoveryservices/mgmt/2016-06-01/recoveryservices"
"github.com/Azure/azure-sdk-for-go/services/redis/mgmt/2018-03-01/redis"
+ "github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay"
"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions"
"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-09-01/locks"
"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-12-01/policy"
@@ -170,6 +171,9 @@ type ArmClient struct {
// Recovery Services
recoveryServicesVaultsClient recoveryservices.VaultsClient
+ // Relay
+ relayNamespacesClient relay.NamespacesClient
+
// Resources
managementLocksClient locks.ManagementLocksClient
deploymentsClient resources.DeploymentsClient
@@ -380,6 +384,7 @@ func getArmClient(c *authentication.Config) (*ArmClient, error) {
client.registerOperationalInsightsClients(endpoint, c.SubscriptionID, auth, sender)
client.registerRecoveryServiceClients(endpoint, c.SubscriptionID, auth)
client.registerRedisClients(endpoint, c.SubscriptionID, auth, sender)
+ client.registerRelayClients(endpoint, c.SubscriptionID, auth, sender)
client.registerResourcesClients(endpoint, c.SubscriptionID, auth)
client.registerSearchClients(endpoint, c.SubscriptionID, auth)
client.registerServiceBusClients(endpoint, c.SubscriptionID, auth)
@@ -812,6 +817,12 @@ func (c *ArmClient) registerRedisClients(endpoint, subscriptionId string, auth a
c.redisPatchSchedulesClient = patchSchedulesClient
}
+func (c *ArmClient) registerRelayClients(endpoint, subscriptionId string, auth autorest.Authorizer, sender autorest.Sender) {
+ relayNamespacesClient := relay.NewNamespacesClientWithBaseURI(endpoint, subscriptionId)
+ c.configureClient(&relayNamespacesClient.Client, auth)
+ c.relayNamespacesClient = relayNamespacesClient
+}
+
func (c *ArmClient) registerResourcesClients(endpoint, subscriptionId string, auth autorest.Authorizer) {
locksClient := locks.NewManagementLocksClientWithBaseURI(endpoint, subscriptionId)
c.configureClient(&locksClient.Client, auth)
diff --git a/azurerm/import_arm_relay_namespace_test.go b/azurerm/import_arm_relay_namespace_test.go
new file mode 100644
index 000000000000..c9607a7ff527
--- /dev/null
+++ b/azurerm/import_arm_relay_namespace_test.go
@@ -0,0 +1,54 @@
+package azurerm
+
+import (
+ "testing"
+
+ "github.com/hashicorp/terraform/helper/acctest"
+ "github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccAzureRMRelayNamespace_importBasic(t *testing.T) {
+ resourceName := "azurerm_relay_namespace.test"
+
+ ri := acctest.RandInt()
+ config := testAccAzureRMRelayNamespace_basic(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMRelayNamespaceDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ },
+ {
+ ResourceName: resourceName,
+ ImportState: true,
+ ImportStateVerify: true,
+ },
+ },
+ })
+}
+
+func TestAccAzureRMRelayNamespace_importComplete(t *testing.T) {
+ resourceName := "azurerm_relay_namespace.test"
+
+ ri := acctest.RandInt()
+ config := testAccAzureRMRelayNamespace_complete(ri, testLocation())
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMRelayNamespaceDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ },
+ {
+ ResourceName: resourceName,
+ ImportState: true,
+ ImportStateVerify: true,
+ },
+ },
+ })
+}
diff --git a/azurerm/provider.go b/azurerm/provider.go
index 96971de5e67e..1f4352bd7176 100644
--- a/azurerm/provider.go
+++ b/azurerm/provider.go
@@ -185,6 +185,7 @@ func Provider() terraform.ResourceProvider {
"azurerm_postgresql_firewall_rule": resourceArmPostgreSQLFirewallRule(),
"azurerm_postgresql_server": resourceArmPostgreSQLServer(),
"azurerm_public_ip": resourceArmPublicIp(),
+ "azurerm_relay_namespace": resourceArmRelayNamespace(),
"azurerm_recovery_services_vault": resourceArmRecoveryServicesVault(),
"azurerm_redis_cache": resourceArmRedisCache(),
"azurerm_redis_firewall_rule": resourceArmRedisFirewallRule(),
@@ -342,6 +343,7 @@ func determineAzureResourceProvidersToRegister(providerList []resources.Provider
"microsoft.insights": {},
"Microsoft.Network": {},
"Microsoft.OperationalInsights": {},
+ "Microsoft.Relay": {},
"Microsoft.Resources": {},
"Microsoft.Search": {},
"Microsoft.ServiceBus": {},
diff --git a/azurerm/resource_arm_relay_namespace.go b/azurerm/resource_arm_relay_namespace.go
new file mode 100644
index 000000000000..049a1cf840ec
--- /dev/null
+++ b/azurerm/resource_arm_relay_namespace.go
@@ -0,0 +1,257 @@
+package azurerm
+
+import (
+ "context"
+ "fmt"
+ "log"
+
+ "time"
+
+ "github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay"
+ "github.com/hashicorp/terraform/helper/resource"
+ "github.com/hashicorp/terraform/helper/schema"
+ "github.com/hashicorp/terraform/helper/validation"
+ "github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/response"
+ "github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func resourceArmRelayNamespace() *schema.Resource {
+ return &schema.Resource{
+ Create: resourceArmRelayNamespaceCreateUpdate,
+ Read: resourceArmRelayNamespaceRead,
+ Update: resourceArmRelayNamespaceCreateUpdate,
+ Delete: resourceArmRelayNamespaceDelete,
+ Importer: &schema.ResourceImporter{
+ State: schema.ImportStatePassthrough,
+ },
+
+ Schema: map[string]*schema.Schema{
+ "name": {
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ ValidateFunc: validation.StringLenBetween(6, 50),
+ },
+
+ "location": locationSchema(),
+
+ "resource_group_name": resourceGroupNameSchema(),
+
+ "sku": {
+ Type: schema.TypeList,
+ Required: true,
+ MaxItems: 1,
+ Elem: &schema.Resource{
+ Schema: map[string]*schema.Schema{
+ "name": {
+ Type: schema.TypeString,
+ Required: true,
+ DiffSuppressFunc: ignoreCaseDiffSuppressFunc,
+ ValidateFunc: validation.StringInSlice([]string{
+ string(relay.Standard),
+ }, true),
+ },
+ },
+ },
+ },
+
+ "metric_id": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "primary_connection_string": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "secondary_connection_string": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "primary_key": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "secondary_key": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "tags": tagsSchema(),
+ },
+ }
+}
+
+func resourceArmRelayNamespaceCreateUpdate(d *schema.ResourceData, meta interface{}) error {
+ client := meta.(*ArmClient).relayNamespacesClient
+ ctx := meta.(*ArmClient).StopContext
+ log.Printf("[INFO] preparing arguments for Relay Namespace creation.")
+
+ name := d.Get("name").(string)
+ location := azureRMNormalizeLocation(d.Get("location").(string))
+ resourceGroup := d.Get("resource_group_name").(string)
+
+ sku := expandRelayNamespaceSku(d)
+ tags := d.Get("tags").(map[string]interface{})
+ expandedTags := expandTags(tags)
+
+ parameters := relay.Namespace{
+ Location: utils.String(location),
+ Sku: sku,
+ NamespaceProperties: &relay.NamespaceProperties{},
+ Tags: expandedTags,
+ }
+
+ future, err := client.CreateOrUpdate(ctx, resourceGroup, name, parameters)
+ if err != nil {
+ return err
+ }
+
+ err = future.WaitForCompletion(ctx, client.Client)
+ if err != nil {
+ return err
+ }
+
+ read, err := client.Get(ctx, resourceGroup, name)
+ if err != nil {
+ return err
+ }
+ if read.ID == nil {
+ return fmt.Errorf("Cannot read Relay Namespace %q (resource group %s) ID", name, resourceGroup)
+ }
+
+ d.SetId(*read.ID)
+
+ return resourceArmRelayNamespaceRead(d, meta)
+}
+
+func resourceArmRelayNamespaceRead(d *schema.ResourceData, meta interface{}) error {
+ client := meta.(*ArmClient).relayNamespacesClient
+ ctx := meta.(*ArmClient).StopContext
+
+ id, err := parseAzureResourceID(d.Id())
+ if err != nil {
+ return err
+ }
+ resourceGroup := id.ResourceGroup
+ name := id.Path["namespaces"]
+
+ resp, err := client.Get(ctx, resourceGroup, name)
+ if err != nil {
+ if utils.ResponseWasNotFound(resp.Response) {
+ d.SetId("")
+ return nil
+ }
+
+ return fmt.Errorf("Error making Read request on Relay Namespace %q (Resource Group %q): %s", name, resourceGroup, err)
+ }
+
+ d.Set("name", name)
+ d.Set("resource_group_name", resourceGroup)
+ if location := resp.Location; location != nil {
+ d.Set("location", azureRMNormalizeLocation(*location))
+ }
+
+ if sku := resp.Sku; sku != nil {
+ flattenedSku := flattenRelayNamespaceSku(sku)
+ if err := d.Set("sku", flattenedSku); err != nil {
+ return fmt.Errorf("Error setting `sku`: %+v", err)
+ }
+ }
+
+ if props := resp.NamespaceProperties; props != nil {
+ d.Set("metric_id", props.MetricID)
+ }
+
+ keysResp, err := client.ListKeys(ctx, resourceGroup, name, "RootManageSharedAccessKey")
+ if err != nil {
+ return fmt.Errorf("Error making ListKeys request on Relay Namespace %q (Resource Group %q): %s", name, resourceGroup, err)
+ }
+
+ d.Set("primary_connection_string", keysResp.PrimaryConnectionString)
+ d.Set("primary_key", keysResp.PrimaryKey)
+ d.Set("secondary_connection_string", keysResp.SecondaryConnectionString)
+ d.Set("secondary_key", keysResp.SecondaryKey)
+
+ flattenAndSetTags(d, resp.Tags)
+
+ return nil
+}
+
+func resourceArmRelayNamespaceDelete(d *schema.ResourceData, meta interface{}) error {
+ client := meta.(*ArmClient).relayNamespacesClient
+ ctx := meta.(*ArmClient).StopContext
+
+ id, err := parseAzureResourceID(d.Id())
+ if err != nil {
+ return err
+ }
+ resourceGroup := id.ResourceGroup
+ name := id.Path["namespaces"]
+
+ future, err := client.Delete(ctx, resourceGroup, name)
+ if err != nil {
+ if response.WasNotFound(future.Response()) {
+ return nil
+ }
+
+ return err
+ }
+
+ // we can't make use of the Future here due to a bug where 404 isn't tracked as Successful
+ log.Printf("[DEBUG] Waiting for Relay Namespace %q (Resource Group %q) to be deleted", name, resourceGroup)
+ stateConf := &resource.StateChangeConf{
+ Pending: []string{"Pending"},
+ Target: []string{"Deleted"},
+ Refresh: relayNamespaceDeleteRefreshFunc(ctx, client, resourceGroup, name),
+ Timeout: 60 * time.Minute,
+ MinTimeout: 15 * time.Second,
+ }
+ if _, err := stateConf.WaitForState(); err != nil {
+ return fmt.Errorf("Error waiting for Relay Namespace %q (Resource Group %q) to be deleted: %s", name, resourceGroup, err)
+ }
+
+ return nil
+}
+
+func relayNamespaceDeleteRefreshFunc(ctx context.Context, client relay.NamespacesClient, resourceGroupName string, name string) resource.StateRefreshFunc {
+ return func() (interface{}, string, error) {
+ res, err := client.Get(ctx, resourceGroupName, name)
+ if err != nil {
+ if utils.ResponseWasNotFound(res.Response) {
+ return res, "Deleted", nil
+ }
+
+ return nil, "Error", fmt.Errorf("Error issuing read request in relayNamespaceDeleteRefreshFunc to Relay Namespace %q (Resource Group %q): %s", name, resourceGroupName, err)
+ }
+
+ return res, "Pending", nil
+ }
+}
+
+func expandRelayNamespaceSku(d *schema.ResourceData) *relay.Sku {
+ vs := d.Get("sku").([]interface{})
+ v := vs[0].(map[string]interface{})
+
+ name := v["name"].(string)
+
+ return &relay.Sku{
+ Name: utils.String(name),
+ Tier: relay.SkuTier(name),
+ }
+}
+
+func flattenRelayNamespaceSku(input *relay.Sku) []interface{} {
+ if input == nil {
+ return []interface{}{}
+ }
+
+ output := make(map[string]interface{}, 0)
+ if name := input.Name; name != nil {
+ output["name"] = *name
+ }
+ return []interface{}{output}
+}
diff --git a/azurerm/resource_arm_relay_namespace_test.go b/azurerm/resource_arm_relay_namespace_test.go
new file mode 100644
index 000000000000..78c169aef22e
--- /dev/null
+++ b/azurerm/resource_arm_relay_namespace_test.go
@@ -0,0 +1,158 @@
+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 TestAccAzureRMRelayNamespace_basic(t *testing.T) {
+ resourceName := "azurerm_relay_namespace.test"
+ ri := acctest.RandInt()
+ location := testLocation()
+ config := testAccAzureRMRelayNamespace_basic(ri, location)
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMRelayNamespaceDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMRelayNamespaceExists(resourceName),
+ resource.TestCheckResourceAttrSet(resourceName, "metric_id"),
+ resource.TestCheckResourceAttrSet(resourceName, "primary_connection_string"),
+ resource.TestCheckResourceAttrSet(resourceName, "secondary_connection_string"),
+ resource.TestCheckResourceAttrSet(resourceName, "primary_key"),
+ resource.TestCheckResourceAttrSet(resourceName, "secondary_key"),
+ ),
+ },
+ },
+ })
+}
+
+func TestAccAzureRMRelayNamespace_complete(t *testing.T) {
+ resourceName := "azurerm_relay_namespace.test"
+ ri := acctest.RandInt()
+ location := testLocation()
+ config := testAccAzureRMRelayNamespace_complete(ri, location)
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testCheckAzureRMRelayNamespaceDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: config,
+ Check: resource.ComposeTestCheckFunc(
+ testCheckAzureRMRelayNamespaceExists(resourceName),
+ resource.TestCheckResourceAttrSet(resourceName, "metric_id"),
+ resource.TestCheckResourceAttrSet(resourceName, "primary_connection_string"),
+ resource.TestCheckResourceAttrSet(resourceName, "secondary_connection_string"),
+ resource.TestCheckResourceAttrSet(resourceName, "primary_key"),
+ resource.TestCheckResourceAttrSet(resourceName, "secondary_key"),
+ ),
+ },
+ },
+ })
+}
+
+func testCheckAzureRMRelayNamespaceExists(resourceName 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[resourceName]
+ if !ok {
+ return fmt.Errorf("Not found: %s", resourceName)
+ }
+
+ resourceGroup := rs.Primary.Attributes["resource_group_name"]
+ name := rs.Primary.Attributes["name"]
+
+ // Ensure resource group exists in API
+ client := testAccProvider.Meta().(*ArmClient).relayNamespacesClient
+ ctx := testAccProvider.Meta().(*ArmClient).StopContext
+
+ resp, err := client.Get(ctx, resourceGroup, name)
+ if err != nil {
+ return fmt.Errorf("Bad: Get on relayNamespacesClient: %+v", err)
+ }
+
+ if resp.StatusCode == http.StatusNotFound {
+ return fmt.Errorf("Bad: Relay Namespace %q (Resource Group: %q) does not exist", name, resourceGroup)
+ }
+
+ return nil
+ }
+}
+
+func testCheckAzureRMRelayNamespaceDestroy(s *terraform.State) error {
+ client := testAccProvider.Meta().(*ArmClient).relayNamespacesClient
+ ctx := testAccProvider.Meta().(*ArmClient).StopContext
+
+ for _, rs := range s.RootModule().Resources {
+ if rs.Type != "azurerm_relay_namespace" {
+ continue
+ }
+
+ resourceGroup := rs.Primary.Attributes["resource_group_name"]
+ name := rs.Primary.Attributes["name"]
+
+ resp, err := client.Get(ctx, resourceGroup, name)
+ if err != nil {
+ return nil
+ }
+
+ if resp.StatusCode != http.StatusNotFound {
+ return fmt.Errorf("Relay Namespace still exists:\n%#v", resp)
+ }
+ }
+
+ return nil
+}
+
+func testAccAzureRMRelayNamespace_basic(rInt int, location string) string {
+ return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+ name = "acctestRG-%d"
+ location = "%s"
+}
+
+resource "azurerm_relay_namespace" "test" {
+ name = "acctestrn-%d"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ name = "Standard"
+ }
+}
+`, rInt, location, rInt)
+}
+
+func testAccAzureRMRelayNamespace_complete(rInt int, location string) string {
+ return fmt.Sprintf(`
+resource "azurerm_resource_group" "test" {
+ name = "acctestRG-%d"
+ location = "%s"
+}
+
+resource "azurerm_relay_namespace" "test" {
+ name = "acctestrn-%d"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+
+ sku {
+ name = "Standard"
+ }
+
+ tags {
+ "Hello" = "World"
+ }
+}
+`, rInt, location, rInt)
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/client.go b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/client.go
new file mode 100644
index 000000000000..a881d83d1356
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/client.go
@@ -0,0 +1,51 @@
+// Package relay implements the Azure ARM Relay service API version 2017-04-01.
+//
+// Use these API to manage Azure Relay resources through Azure Resource Manager.
+package relay
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "github.com/Azure/go-autorest/autorest"
+)
+
+const (
+ // DefaultBaseURI is the default URI used for the service Relay
+ DefaultBaseURI = "https://management.azure.com"
+)
+
+// BaseClient is the base client for Relay.
+type BaseClient struct {
+ autorest.Client
+ BaseURI string
+ SubscriptionID string
+}
+
+// New creates an instance of the BaseClient client.
+func New(subscriptionID string) BaseClient {
+ return NewWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWithBaseURI creates an instance of the BaseClient client.
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+ return BaseClient{
+ Client: autorest.NewClientWithUserAgent(UserAgent()),
+ BaseURI: baseURI,
+ SubscriptionID: subscriptionID,
+ }
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/hybridconnections.go b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/hybridconnections.go
new file mode 100644
index 000000000000..9310fa033510
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/hybridconnections.go
@@ -0,0 +1,942 @@
+package relay
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// HybridConnectionsClient is the use these API to manage Azure Relay resources through Azure Resource Manager.
+type HybridConnectionsClient struct {
+ BaseClient
+}
+
+// NewHybridConnectionsClient creates an instance of the HybridConnectionsClient client.
+func NewHybridConnectionsClient(subscriptionID string) HybridConnectionsClient {
+ return NewHybridConnectionsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewHybridConnectionsClientWithBaseURI creates an instance of the HybridConnectionsClient client.
+func NewHybridConnectionsClientWithBaseURI(baseURI string, subscriptionID string) HybridConnectionsClient {
+ return HybridConnectionsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a service hybrid connection. This operation is idempotent.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+// parameters - parameters supplied to create a hybrid connection.
+func (client HybridConnectionsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, parameters 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}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.HybridConnectionProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.HybridConnectionProperties.ListenerCount", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.HybridConnectionProperties.ListenerCount", Name: validation.InclusiveMaximum, Rule: 25, Chain: nil},
+ {Target: "parameters.HybridConnectionProperties.ListenerCount", Name: validation.InclusiveMinimum, Rule: 0, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client HybridConnectionsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, parameters HybridConnection) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) CreateOrUpdateResponder(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
+}
+
+// CreateOrUpdateAuthorizationRule creates or updates an authorization rule for a hybrid connection.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+// authorizationRuleName - the authorization rule name.
+// parameters - the authorization rule parameters.
+func (client HybridConnectionsClient) CreateOrUpdateAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string, parameters AuthorizationRule) (result AuthorizationRule, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties.Rights", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties.Rights", Name: validation.UniqueItems, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "CreateOrUpdateAuthorizationRule", err.Error())
+ }
+
+ req, err := client.CreateOrUpdateAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName, authorizationRuleName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "CreateOrUpdateAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "CreateOrUpdateAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "CreateOrUpdateAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateAuthorizationRulePreparer prepares the CreateOrUpdateAuthorizationRule request.
+func (client HybridConnectionsClient) CreateOrUpdateAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string, parameters AuthorizationRule) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) CreateOrUpdateAuthorizationRuleResponder(resp *http.Response) (result AuthorizationRule, 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 hybrid connection.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+func (client HybridConnectionsClient) Delete(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName 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}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "Delete", err.Error())
+ }
+
+ req, err := client.DeletePreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "Delete", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client HybridConnectionsClient) DeletePreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) 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
+}
+
+// DeleteAuthorizationRule deletes a hybrid connection authorization rule.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+// authorizationRuleName - the authorization rule name.
+func (client HybridConnectionsClient) DeleteAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName 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}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "DeleteAuthorizationRule", err.Error())
+ }
+
+ req, err := client.DeleteAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "DeleteAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "DeleteAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "DeleteAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteAuthorizationRulePreparer prepares the DeleteAuthorizationRule request.
+func (client HybridConnectionsClient) DeleteAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) DeleteAuthorizationRuleResponder(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 returns the description for the specified hybrid connection.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+func (client HybridConnectionsClient) Get(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName 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}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "Get", err.Error())
+ }
+
+ req, err := client.GetPreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client HybridConnectionsClient) GetPreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) GetResponder(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
+}
+
+// GetAuthorizationRule hybrid connection authorization rule for a hybrid connection by name.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+// authorizationRuleName - the authorization rule name.
+func (client HybridConnectionsClient) GetAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string) (result AuthorizationRule, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "GetAuthorizationRule", err.Error())
+ }
+
+ req, err := client.GetAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "GetAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "GetAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "GetAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetAuthorizationRulePreparer prepares the GetAuthorizationRule request.
+func (client HybridConnectionsClient) GetAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) GetAuthorizationRuleResponder(resp *http.Response) (result AuthorizationRule, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAuthorizationRules authorization rules for a hybrid connection.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+func (client HybridConnectionsClient) ListAuthorizationRules(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string) (result AuthorizationRuleListResultPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "ListAuthorizationRules", err.Error())
+ }
+
+ result.fn = client.listAuthorizationRulesNextResults
+ req, err := client.ListAuthorizationRulesPreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListAuthorizationRules", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAuthorizationRulesSender(req)
+ if err != nil {
+ result.arlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListAuthorizationRules", resp, "Failure sending request")
+ return
+ }
+
+ result.arlr, err = client.ListAuthorizationRulesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListAuthorizationRules", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListAuthorizationRulesPreparer prepares the ListAuthorizationRules request.
+func (client HybridConnectionsClient) ListAuthorizationRulesPreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}/authorizationRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) ListAuthorizationRulesResponder(resp *http.Response) (result AuthorizationRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAuthorizationRulesNextResults retrieves the next set of results, if any.
+func (client HybridConnectionsClient) listAuthorizationRulesNextResults(lastResults AuthorizationRuleListResult) (result AuthorizationRuleListResult, err error) {
+ req, err := lastResults.authorizationRuleListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "listAuthorizationRulesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAuthorizationRulesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "listAuthorizationRulesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAuthorizationRulesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "listAuthorizationRulesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAuthorizationRulesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client HybridConnectionsClient) ListAuthorizationRulesComplete(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string) (result AuthorizationRuleListResultIterator, err error) {
+ result.page, err = client.ListAuthorizationRules(ctx, resourceGroupName, namespaceName, hybridConnectionName)
+ return
+}
+
+// ListByNamespace lists the hybrid connection within the namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+func (client HybridConnectionsClient) ListByNamespace(ctx context.Context, resourceGroupName string, namespaceName string) (result HybridConnectionListResultPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "ListByNamespace", err.Error())
+ }
+
+ result.fn = client.listByNamespaceNextResults
+ req, err := client.ListByNamespacePreparer(ctx, resourceGroupName, namespaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListByNamespace", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByNamespaceSender(req)
+ if err != nil {
+ result.hclr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListByNamespace", resp, "Failure sending request")
+ return
+ }
+
+ result.hclr, err = client.ListByNamespaceResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListByNamespace", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByNamespacePreparer prepares the ListByNamespace request.
+func (client HybridConnectionsClient) ListByNamespacePreparer(ctx context.Context, resourceGroupName string, namespaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/hybridConnections", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByNamespaceSender sends the ListByNamespace request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) ListByNamespaceSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByNamespaceResponder handles the response to the ListByNamespace request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) ListByNamespaceResponder(resp *http.Response) (result HybridConnectionListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByNamespaceNextResults retrieves the next set of results, if any.
+func (client HybridConnectionsClient) listByNamespaceNextResults(lastResults HybridConnectionListResult) (result HybridConnectionListResult, err error) {
+ req, err := lastResults.hybridConnectionListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "listByNamespaceNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByNamespaceSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "listByNamespaceNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByNamespaceResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "listByNamespaceNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByNamespaceComplete enumerates all values, automatically crossing page boundaries as required.
+func (client HybridConnectionsClient) ListByNamespaceComplete(ctx context.Context, resourceGroupName string, namespaceName string) (result HybridConnectionListResultIterator, err error) {
+ result.page, err = client.ListByNamespace(ctx, resourceGroupName, namespaceName)
+ return
+}
+
+// ListKeys primary and secondary connection strings to the hybrid connection.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+// authorizationRuleName - the authorization rule name.
+func (client HybridConnectionsClient) ListKeys(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string) (result AccessKeys, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "ListKeys", err.Error())
+ }
+
+ req, err := client.ListKeysPreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "ListKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListKeysPreparer prepares the ListKeys request.
+func (client HybridConnectionsClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-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.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}/authorizationRules/{authorizationRuleName}/listKeys", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListKeysSender sends the ListKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) ListKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListKeysResponder handles the response to the ListKeys request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) ListKeysResponder(resp *http.Response) (result AccessKeys, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RegenerateKeys regenerates the primary or secondary connection strings to the hybrid connection.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// hybridConnectionName - the hybrid connection name.
+// authorizationRuleName - the authorization rule name.
+// parameters - parameters supplied to regenerate authorization rule.
+func (client HybridConnectionsClient) RegenerateKeys(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string, parameters RegenerateAccessKeyParameters) (result AccessKeys, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: hybridConnectionName,
+ Constraints: []validation.Constraint{{Target: "hybridConnectionName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.HybridConnectionsClient", "RegenerateKeys", err.Error())
+ }
+
+ req, err := client.RegenerateKeysPreparer(ctx, resourceGroupName, namespaceName, hybridConnectionName, authorizationRuleName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "RegenerateKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RegenerateKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "RegenerateKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RegenerateKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.HybridConnectionsClient", "RegenerateKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RegenerateKeysPreparer prepares the RegenerateKeys request.
+func (client HybridConnectionsClient) RegenerateKeysPreparer(ctx context.Context, resourceGroupName string, namespaceName string, hybridConnectionName string, authorizationRuleName string, parameters RegenerateAccessKeyParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "hybridConnectionName": autorest.Encode("path", hybridConnectionName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/hybridConnections/{hybridConnectionName}/authorizationRules/{authorizationRuleName}/regenerateKeys", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RegenerateKeysSender sends the RegenerateKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client HybridConnectionsClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always
+// closes the http.Response Body.
+func (client HybridConnectionsClient) RegenerateKeysResponder(resp *http.Response) (result AccessKeys, 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/services/relay/mgmt/2017-04-01/relay/models.go b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/models.go
new file mode 100644
index 000000000000..fc6eb79269b4
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/models.go
@@ -0,0 +1,1425 @@
+package relay
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "encoding/json"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/date"
+ "github.com/Azure/go-autorest/autorest/to"
+ "net/http"
+)
+
+// AccessRights enumerates the values for access rights.
+type AccessRights string
+
+const (
+ // Listen ...
+ Listen AccessRights = "Listen"
+ // Manage ...
+ Manage AccessRights = "Manage"
+ // Send ...
+ Send AccessRights = "Send"
+)
+
+// PossibleAccessRightsValues returns an array of possible values for the AccessRights const type.
+func PossibleAccessRightsValues() []AccessRights {
+ return []AccessRights{Listen, Manage, Send}
+}
+
+// KeyType enumerates the values for key type.
+type KeyType string
+
+const (
+ // PrimaryKey ...
+ PrimaryKey KeyType = "PrimaryKey"
+ // SecondaryKey ...
+ SecondaryKey KeyType = "SecondaryKey"
+)
+
+// PossibleKeyTypeValues returns an array of possible values for the KeyType const type.
+func PossibleKeyTypeValues() []KeyType {
+ return []KeyType{PrimaryKey, SecondaryKey}
+}
+
+// ProvisioningStateEnum enumerates the values for provisioning state enum.
+type ProvisioningStateEnum string
+
+const (
+ // Created ...
+ Created ProvisioningStateEnum = "Created"
+ // Deleted ...
+ Deleted ProvisioningStateEnum = "Deleted"
+ // Failed ...
+ Failed ProvisioningStateEnum = "Failed"
+ // Succeeded ...
+ Succeeded ProvisioningStateEnum = "Succeeded"
+ // Unknown ...
+ Unknown ProvisioningStateEnum = "Unknown"
+ // Updating ...
+ Updating ProvisioningStateEnum = "Updating"
+)
+
+// PossibleProvisioningStateEnumValues returns an array of possible values for the ProvisioningStateEnum const type.
+func PossibleProvisioningStateEnumValues() []ProvisioningStateEnum {
+ return []ProvisioningStateEnum{Created, Deleted, Failed, Succeeded, Unknown, Updating}
+}
+
+// RelaytypeEnum enumerates the values for relaytype enum.
+type RelaytypeEnum string
+
+const (
+ // HTTP ...
+ HTTP RelaytypeEnum = "Http"
+ // NetTCP ...
+ NetTCP RelaytypeEnum = "NetTcp"
+)
+
+// PossibleRelaytypeEnumValues returns an array of possible values for the RelaytypeEnum const type.
+func PossibleRelaytypeEnumValues() []RelaytypeEnum {
+ return []RelaytypeEnum{HTTP, NetTCP}
+}
+
+// SkuTier enumerates the values for sku tier.
+type SkuTier string
+
+const (
+ // Standard ...
+ Standard SkuTier = "Standard"
+)
+
+// PossibleSkuTierValues returns an array of possible values for the SkuTier const type.
+func PossibleSkuTierValues() []SkuTier {
+ return []SkuTier{Standard}
+}
+
+// UnavailableReason enumerates the values for unavailable reason.
+type UnavailableReason string
+
+const (
+ // InvalidName ...
+ InvalidName UnavailableReason = "InvalidName"
+ // NameInLockdown ...
+ NameInLockdown UnavailableReason = "NameInLockdown"
+ // NameInUse ...
+ NameInUse UnavailableReason = "NameInUse"
+ // None ...
+ None UnavailableReason = "None"
+ // SubscriptionIsDisabled ...
+ SubscriptionIsDisabled UnavailableReason = "SubscriptionIsDisabled"
+ // TooManyNamespaceInCurrentSubscription ...
+ TooManyNamespaceInCurrentSubscription UnavailableReason = "TooManyNamespaceInCurrentSubscription"
+)
+
+// PossibleUnavailableReasonValues returns an array of possible values for the UnavailableReason const type.
+func PossibleUnavailableReasonValues() []UnavailableReason {
+ return []UnavailableReason{InvalidName, NameInLockdown, NameInUse, None, SubscriptionIsDisabled, TooManyNamespaceInCurrentSubscription}
+}
+
+// AccessKeys namespace/Relay Connection String
+type AccessKeys struct {
+ autorest.Response `json:"-"`
+ // PrimaryConnectionString - Primary connection string of the created namespace authorization rule.
+ PrimaryConnectionString *string `json:"primaryConnectionString,omitempty"`
+ // SecondaryConnectionString - Secondary connection string of the created namespace authorization rule.
+ SecondaryConnectionString *string `json:"secondaryConnectionString,omitempty"`
+ // PrimaryKey - A base64-encoded 256-bit primary key for signing and validating the SAS token.
+ PrimaryKey *string `json:"primaryKey,omitempty"`
+ // SecondaryKey - A base64-encoded 256-bit secondary key for signing and validating the SAS token.
+ SecondaryKey *string `json:"secondaryKey,omitempty"`
+ // KeyName - A string that describes the authorization rule.
+ KeyName *string `json:"keyName,omitempty"`
+}
+
+// AuthorizationRule description of a namespace authorization rule.
+type AuthorizationRule struct {
+ autorest.Response `json:"-"`
+ // AuthorizationRuleProperties - Authorization rule properties.
+ *AuthorizationRuleProperties `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for AuthorizationRule.
+func (ar AuthorizationRule) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if ar.AuthorizationRuleProperties != nil {
+ objectMap["properties"] = ar.AuthorizationRuleProperties
+ }
+ if ar.ID != nil {
+ objectMap["id"] = ar.ID
+ }
+ if ar.Name != nil {
+ objectMap["name"] = ar.Name
+ }
+ if ar.Type != nil {
+ objectMap["type"] = ar.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for AuthorizationRule struct.
+func (ar *AuthorizationRule) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var authorizationRuleProperties AuthorizationRuleProperties
+ err = json.Unmarshal(*v, &authorizationRuleProperties)
+ if err != nil {
+ return err
+ }
+ ar.AuthorizationRuleProperties = &authorizationRuleProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ ar.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ ar.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ ar.Type = &typeVar
+ }
+ }
+ }
+
+ return nil
+}
+
+// AuthorizationRuleListResult the response from the list namespace operation.
+type AuthorizationRuleListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Result of the list authorization rules operation.
+ Value *[]AuthorizationRule `json:"value,omitempty"`
+ // NextLink - Link to the next set of results. Not empty if value contains incomplete list of authorization rules.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// AuthorizationRuleListResultIterator provides access to a complete listing of AuthorizationRule values.
+type AuthorizationRuleListResultIterator struct {
+ i int
+ page AuthorizationRuleListResultPage
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *AuthorizationRuleListResultIterator) Next() error {
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err := iter.page.Next()
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter AuthorizationRuleListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter AuthorizationRuleListResultIterator) Response() AuthorizationRuleListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter AuthorizationRuleListResultIterator) Value() AuthorizationRule {
+ if !iter.page.NotDone() {
+ return AuthorizationRule{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (arlr AuthorizationRuleListResult) IsEmpty() bool {
+ return arlr.Value == nil || len(*arlr.Value) == 0
+}
+
+// authorizationRuleListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (arlr AuthorizationRuleListResult) authorizationRuleListResultPreparer() (*http.Request, error) {
+ if arlr.NextLink == nil || len(to.String(arlr.NextLink)) < 1 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(arlr.NextLink)))
+}
+
+// AuthorizationRuleListResultPage contains a page of AuthorizationRule values.
+type AuthorizationRuleListResultPage struct {
+ fn func(AuthorizationRuleListResult) (AuthorizationRuleListResult, error)
+ arlr AuthorizationRuleListResult
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *AuthorizationRuleListResultPage) Next() error {
+ next, err := page.fn(page.arlr)
+ if err != nil {
+ return err
+ }
+ page.arlr = next
+ return nil
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page AuthorizationRuleListResultPage) NotDone() bool {
+ return !page.arlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page AuthorizationRuleListResultPage) Response() AuthorizationRuleListResult {
+ return page.arlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page AuthorizationRuleListResultPage) Values() []AuthorizationRule {
+ if page.arlr.IsEmpty() {
+ return nil
+ }
+ return *page.arlr.Value
+}
+
+// AuthorizationRuleProperties authorization rule properties.
+type AuthorizationRuleProperties struct {
+ // Rights - The rights associated with the rule.
+ Rights *[]AccessRights `json:"rights,omitempty"`
+}
+
+// CheckNameAvailability description of the check name availability request properties.
+type CheckNameAvailability struct {
+ // Name - The namespace name to check for availability. The namespace name can contain only letters, numbers, and hyphens. The namespace must start with a letter, and it must end with a letter or number.
+ Name *string `json:"name,omitempty"`
+}
+
+// CheckNameAvailabilityResult description of the check name availability request properties.
+type CheckNameAvailabilityResult struct {
+ autorest.Response `json:"-"`
+ // Message - The detailed info regarding the reason associated with the namespace.
+ Message *string `json:"message,omitempty"`
+ // NameAvailable - Value indicating namespace is available. Returns true if the namespace is available; otherwise, false.
+ NameAvailable *bool `json:"nameAvailable,omitempty"`
+ // Reason - The reason for unavailability of a namespace. Possible values include: 'None', 'InvalidName', 'SubscriptionIsDisabled', 'NameInUse', 'NameInLockdown', 'TooManyNamespaceInCurrentSubscription'
+ Reason UnavailableReason `json:"reason,omitempty"`
+}
+
+// ErrorResponse error reponse indicates Relay service is not able to process the incoming request. The reason is
+// provided in the error message.
+type ErrorResponse struct {
+ // Code - Error code.
+ Code *string `json:"code,omitempty"`
+ // Message - Error message indicating why the operation failed.
+ Message *string `json:"message,omitempty"`
+}
+
+// HybridConnection description of hybrid connection resource.
+type HybridConnection struct {
+ autorest.Response `json:"-"`
+ // HybridConnectionProperties - Properties of the HybridConnection.
+ *HybridConnectionProperties `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for HybridConnection.
+func (hc HybridConnection) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if hc.HybridConnectionProperties != nil {
+ objectMap["properties"] = hc.HybridConnectionProperties
+ }
+ if hc.ID != nil {
+ objectMap["id"] = hc.ID
+ }
+ if hc.Name != nil {
+ objectMap["name"] = hc.Name
+ }
+ if hc.Type != nil {
+ objectMap["type"] = hc.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for HybridConnection struct.
+func (hc *HybridConnection) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var hybridConnectionProperties HybridConnectionProperties
+ err = json.Unmarshal(*v, &hybridConnectionProperties)
+ if err != nil {
+ return err
+ }
+ hc.HybridConnectionProperties = &hybridConnectionProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ hc.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ hc.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ hc.Type = &typeVar
+ }
+ }
+ }
+
+ return nil
+}
+
+// HybridConnectionListResult the response of the list hybrid connection operation.
+type HybridConnectionListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Result of the list hybrid connections.
+ Value *[]HybridConnection `json:"value,omitempty"`
+ // NextLink - Link to the next set of results. Not empty if value contains incomplete list hybrid connection operation.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// HybridConnectionListResultIterator provides access to a complete listing of HybridConnection values.
+type HybridConnectionListResultIterator struct {
+ i int
+ page HybridConnectionListResultPage
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *HybridConnectionListResultIterator) Next() error {
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err := iter.page.Next()
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter HybridConnectionListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter HybridConnectionListResultIterator) Response() HybridConnectionListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter HybridConnectionListResultIterator) Value() HybridConnection {
+ if !iter.page.NotDone() {
+ return HybridConnection{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (hclr HybridConnectionListResult) IsEmpty() bool {
+ return hclr.Value == nil || len(*hclr.Value) == 0
+}
+
+// hybridConnectionListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (hclr HybridConnectionListResult) hybridConnectionListResultPreparer() (*http.Request, error) {
+ if hclr.NextLink == nil || len(to.String(hclr.NextLink)) < 1 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(hclr.NextLink)))
+}
+
+// HybridConnectionListResultPage contains a page of HybridConnection values.
+type HybridConnectionListResultPage struct {
+ fn func(HybridConnectionListResult) (HybridConnectionListResult, error)
+ hclr HybridConnectionListResult
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *HybridConnectionListResultPage) Next() error {
+ next, err := page.fn(page.hclr)
+ if err != nil {
+ return err
+ }
+ page.hclr = next
+ return nil
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page HybridConnectionListResultPage) NotDone() bool {
+ return !page.hclr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page HybridConnectionListResultPage) Response() HybridConnectionListResult {
+ return page.hclr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page HybridConnectionListResultPage) Values() []HybridConnection {
+ if page.hclr.IsEmpty() {
+ return nil
+ }
+ return *page.hclr.Value
+}
+
+// HybridConnectionProperties properties of the HybridConnection.
+type HybridConnectionProperties struct {
+ // CreatedAt - The time the hybrid connection was created.
+ CreatedAt *date.Time `json:"createdAt,omitempty"`
+ // UpdatedAt - The time the namespace was updated.
+ UpdatedAt *date.Time `json:"updatedAt,omitempty"`
+ // ListenerCount - The number of listeners for this hybrid connection. Note that min : 1 and max:25 are supported.
+ ListenerCount *int32 `json:"listenerCount,omitempty"`
+ // RequiresClientAuthorization - Returns true if client authorization is needed for this hybrid connection; otherwise, false.
+ RequiresClientAuthorization *bool `json:"requiresClientAuthorization,omitempty"`
+ // UserMetadata - The usermetadata is a placeholder to store user-defined string data for the hybrid connection endpoint. For example, it can be used to store descriptive data, such as a list of teams and their contact information. Also, user-defined configuration settings can be stored.
+ UserMetadata *string `json:"userMetadata,omitempty"`
+}
+
+// Namespace description of a namespace resource.
+type Namespace struct {
+ autorest.Response `json:"-"`
+ // Sku - SKU of the namespace.
+ Sku *Sku `json:"sku,omitempty"`
+ // NamespaceProperties - Description of Relay namespace
+ *NamespaceProperties `json:"properties,omitempty"`
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for Namespace.
+func (n Namespace) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if n.Sku != nil {
+ objectMap["sku"] = n.Sku
+ }
+ if n.NamespaceProperties != nil {
+ objectMap["properties"] = n.NamespaceProperties
+ }
+ if n.Location != nil {
+ objectMap["location"] = n.Location
+ }
+ if n.Tags != nil {
+ objectMap["tags"] = n.Tags
+ }
+ if n.ID != nil {
+ objectMap["id"] = n.ID
+ }
+ if n.Name != nil {
+ objectMap["name"] = n.Name
+ }
+ if n.Type != nil {
+ objectMap["type"] = n.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for Namespace struct.
+func (n *Namespace) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ n.Sku = &sku
+ }
+ case "properties":
+ if v != nil {
+ var namespaceProperties NamespaceProperties
+ err = json.Unmarshal(*v, &namespaceProperties)
+ if err != nil {
+ return err
+ }
+ n.NamespaceProperties = &namespaceProperties
+ }
+ case "location":
+ if v != nil {
+ var location string
+ err = json.Unmarshal(*v, &location)
+ if err != nil {
+ return err
+ }
+ n.Location = &location
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ n.Tags = tags
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ n.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ n.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ n.Type = &typeVar
+ }
+ }
+ }
+
+ return nil
+}
+
+// NamespaceListResult the response from the list namespace operation.
+type NamespaceListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Result of the list namespace operation.
+ Value *[]Namespace `json:"value,omitempty"`
+ // NextLink - Link to the next set of results. Not empty if value contains incomplete list of namespaces.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// NamespaceListResultIterator provides access to a complete listing of Namespace values.
+type NamespaceListResultIterator struct {
+ i int
+ page NamespaceListResultPage
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *NamespaceListResultIterator) Next() error {
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err := iter.page.Next()
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter NamespaceListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter NamespaceListResultIterator) Response() NamespaceListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter NamespaceListResultIterator) Value() Namespace {
+ if !iter.page.NotDone() {
+ return Namespace{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (nlr NamespaceListResult) IsEmpty() bool {
+ return nlr.Value == nil || len(*nlr.Value) == 0
+}
+
+// namespaceListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (nlr NamespaceListResult) namespaceListResultPreparer() (*http.Request, error) {
+ if nlr.NextLink == nil || len(to.String(nlr.NextLink)) < 1 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(nlr.NextLink)))
+}
+
+// NamespaceListResultPage contains a page of Namespace values.
+type NamespaceListResultPage struct {
+ fn func(NamespaceListResult) (NamespaceListResult, error)
+ nlr NamespaceListResult
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *NamespaceListResultPage) Next() error {
+ next, err := page.fn(page.nlr)
+ if err != nil {
+ return err
+ }
+ page.nlr = next
+ return nil
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page NamespaceListResultPage) NotDone() bool {
+ return !page.nlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page NamespaceListResultPage) Response() NamespaceListResult {
+ return page.nlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page NamespaceListResultPage) Values() []Namespace {
+ if page.nlr.IsEmpty() {
+ return nil
+ }
+ return *page.nlr.Value
+}
+
+// NamespaceProperties properties of the namespace.
+type NamespaceProperties struct {
+ // ProvisioningState - Possible values include: 'Created', 'Succeeded', 'Deleted', 'Failed', 'Updating', 'Unknown'
+ ProvisioningState ProvisioningStateEnum `json:"provisioningState,omitempty"`
+ // CreatedAt - The time the namespace was created.
+ CreatedAt *date.Time `json:"createdAt,omitempty"`
+ // UpdatedAt - The time the namespace was updated.
+ UpdatedAt *date.Time `json:"updatedAt,omitempty"`
+ // ServiceBusEndpoint - Endpoint you can use to perform Service Bus operations.
+ ServiceBusEndpoint *string `json:"serviceBusEndpoint,omitempty"`
+ // MetricID - Identifier for Azure Insights metrics.
+ MetricID *string `json:"metricId,omitempty"`
+}
+
+// NamespacesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running
+// operation.
+type NamespacesCreateOrUpdateFuture struct {
+ azure.Future
+ req *http.Request
+}
+
+// Result returns the result of the asynchronous operation.
+// If the operation has not completed it will return an error.
+func (future NamespacesCreateOrUpdateFuture) Result(client NamespacesClient) (n Namespace, err error) {
+ var done bool
+ done, err = future.Done(client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ return n, azure.NewAsyncOpIncompleteError("relay.NamespacesCreateOrUpdateFuture")
+ }
+ if future.PollingMethod() == azure.PollingLocation {
+ n, err = client.CreateOrUpdateResponder(future.Response())
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesCreateOrUpdateFuture", "Result", future.Response(), "Failure responding to request")
+ }
+ return
+ }
+ var req *http.Request
+ var resp *http.Response
+ if future.PollingURL() != "" {
+ req, err = http.NewRequest(http.MethodGet, future.PollingURL(), nil)
+ if err != nil {
+ return
+ }
+ } else {
+ req = autorest.ChangeToGet(future.req)
+ }
+ resp, err = autorest.SendWithSender(client, req,
+ autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesCreateOrUpdateFuture", "Result", resp, "Failure sending request")
+ return
+ }
+ n, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesCreateOrUpdateFuture", "Result", resp, "Failure responding to request")
+ }
+ return
+}
+
+// NamespacesDeleteFuture an abstraction for monitoring and retrieving the results of a long-running operation.
+type NamespacesDeleteFuture struct {
+ azure.Future
+ req *http.Request
+}
+
+// Result returns the result of the asynchronous operation.
+// If the operation has not completed it will return an error.
+func (future NamespacesDeleteFuture) Result(client NamespacesClient) (ar autorest.Response, err error) {
+ var done bool
+ done, err = future.Done(client)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesDeleteFuture", "Result", future.Response(), "Polling failure")
+ return
+ }
+ if !done {
+ return ar, azure.NewAsyncOpIncompleteError("relay.NamespacesDeleteFuture")
+ }
+ if future.PollingMethod() == azure.PollingLocation {
+ ar, err = client.DeleteResponder(future.Response())
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesDeleteFuture", "Result", future.Response(), "Failure responding to request")
+ }
+ return
+ }
+ var req *http.Request
+ var resp *http.Response
+ if future.PollingURL() != "" {
+ req, err = http.NewRequest(http.MethodGet, future.PollingURL(), nil)
+ if err != nil {
+ return
+ }
+ } else {
+ req = autorest.ChangeToGet(future.req)
+ }
+ resp, err = autorest.SendWithSender(client, req,
+ autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesDeleteFuture", "Result", resp, "Failure sending request")
+ return
+ }
+ ar, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesDeleteFuture", "Result", resp, "Failure responding to request")
+ }
+ return
+}
+
+// Operation a Relay REST API operation.
+type Operation struct {
+ // Name - Operation name: {provider}/{resource}/{operation}
+ Name *string `json:"name,omitempty"`
+ // Display - The object that represents the operation.
+ Display *OperationDisplay `json:"display,omitempty"`
+}
+
+// OperationDisplay the object that represents the operation.
+type OperationDisplay struct {
+ // Provider - Service provider: Relay.
+ Provider *string `json:"provider,omitempty"`
+ // Resource - Resource on which the operation is performed: Invoice, etc.
+ Resource *string `json:"resource,omitempty"`
+ // Operation - Operation type: Read, write, delete, etc.
+ Operation *string `json:"operation,omitempty"`
+}
+
+// OperationListResult result of the request to list Relay operations. It contains a list of operations and a URL
+// link to get the next set of results.
+type OperationListResult struct {
+ autorest.Response `json:"-"`
+ // Value - List of Relay operations supported by resource provider.
+ Value *[]Operation `json:"value,omitempty"`
+ // NextLink - URL to get the next set of operation list results if there are any.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// OperationListResultIterator provides access to a complete listing of Operation values.
+type OperationListResultIterator struct {
+ i int
+ page OperationListResultPage
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *OperationListResultIterator) Next() error {
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err := iter.page.Next()
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter OperationListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter OperationListResultIterator) Response() OperationListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter OperationListResultIterator) Value() Operation {
+ if !iter.page.NotDone() {
+ return Operation{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (olr OperationListResult) IsEmpty() bool {
+ return olr.Value == nil || len(*olr.Value) == 0
+}
+
+// operationListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (olr OperationListResult) operationListResultPreparer() (*http.Request, error) {
+ if olr.NextLink == nil || len(to.String(olr.NextLink)) < 1 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(olr.NextLink)))
+}
+
+// OperationListResultPage contains a page of Operation values.
+type OperationListResultPage struct {
+ fn func(OperationListResult) (OperationListResult, error)
+ olr OperationListResult
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *OperationListResultPage) Next() error {
+ next, err := page.fn(page.olr)
+ if err != nil {
+ return err
+ }
+ page.olr = next
+ return nil
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page OperationListResultPage) NotDone() bool {
+ return !page.olr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page OperationListResultPage) Response() OperationListResult {
+ return page.olr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page OperationListResultPage) Values() []Operation {
+ if page.olr.IsEmpty() {
+ return nil
+ }
+ return *page.olr.Value
+}
+
+// RegenerateAccessKeyParameters parameters supplied to the regenerate authorization rule operation, specifies
+// which key neeeds to be reset.
+type RegenerateAccessKeyParameters struct {
+ // KeyType - The access key to regenerate. Possible values include: 'PrimaryKey', 'SecondaryKey'
+ KeyType KeyType `json:"keyType,omitempty"`
+ // Key - Optional. If the key value is provided, this is set to key type, or autogenerated key value set for key type.
+ Key *string `json:"key,omitempty"`
+}
+
+// Resource the resource definition.
+type Resource struct {
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// ResourceNamespacePatch definition of resource.
+type ResourceNamespacePatch struct {
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ResourceNamespacePatch.
+func (rnp ResourceNamespacePatch) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rnp.Tags != nil {
+ objectMap["tags"] = rnp.Tags
+ }
+ if rnp.ID != nil {
+ objectMap["id"] = rnp.ID
+ }
+ if rnp.Name != nil {
+ objectMap["name"] = rnp.Name
+ }
+ if rnp.Type != nil {
+ objectMap["type"] = rnp.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// Sku SKU of the namespace.
+type Sku struct {
+ // Name - Name of this SKU.
+ Name *string `json:"name,omitempty"`
+ // Tier - The tier of this SKU. Possible values include: 'Standard'
+ Tier SkuTier `json:"tier,omitempty"`
+}
+
+// TrackedResource definition of resource.
+type TrackedResource struct {
+ // Location - Resource location.
+ Location *string `json:"location,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for TrackedResource.
+func (tr TrackedResource) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if tr.Location != nil {
+ objectMap["location"] = tr.Location
+ }
+ if tr.Tags != nil {
+ objectMap["tags"] = tr.Tags
+ }
+ if tr.ID != nil {
+ objectMap["id"] = tr.ID
+ }
+ if tr.Name != nil {
+ objectMap["name"] = tr.Name
+ }
+ if tr.Type != nil {
+ objectMap["type"] = tr.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// UpdateParameters description of a namespace resource.
+type UpdateParameters struct {
+ // Sku - SKU of the namespace.
+ Sku *Sku `json:"sku,omitempty"`
+ // NamespaceProperties - Description of Relay namespace.
+ *NamespaceProperties `json:"properties,omitempty"`
+ // Tags - Resource tags.
+ Tags map[string]*string `json:"tags"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for UpdateParameters.
+func (up UpdateParameters) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if up.Sku != nil {
+ objectMap["sku"] = up.Sku
+ }
+ if up.NamespaceProperties != nil {
+ objectMap["properties"] = up.NamespaceProperties
+ }
+ if up.Tags != nil {
+ objectMap["tags"] = up.Tags
+ }
+ if up.ID != nil {
+ objectMap["id"] = up.ID
+ }
+ if up.Name != nil {
+ objectMap["name"] = up.Name
+ }
+ if up.Type != nil {
+ objectMap["type"] = up.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for UpdateParameters struct.
+func (up *UpdateParameters) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "sku":
+ if v != nil {
+ var sku Sku
+ err = json.Unmarshal(*v, &sku)
+ if err != nil {
+ return err
+ }
+ up.Sku = &sku
+ }
+ case "properties":
+ if v != nil {
+ var namespaceProperties NamespaceProperties
+ err = json.Unmarshal(*v, &namespaceProperties)
+ if err != nil {
+ return err
+ }
+ up.NamespaceProperties = &namespaceProperties
+ }
+ case "tags":
+ if v != nil {
+ var tags map[string]*string
+ err = json.Unmarshal(*v, &tags)
+ if err != nil {
+ return err
+ }
+ up.Tags = tags
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ up.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ up.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ up.Type = &typeVar
+ }
+ }
+ }
+
+ return nil
+}
+
+// WcfRelay description of the WCF relay resource.
+type WcfRelay struct {
+ autorest.Response `json:"-"`
+ // WcfRelayProperties - Properties of the WCF relay.
+ *WcfRelayProperties `json:"properties,omitempty"`
+ // ID - Resource ID.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource name.
+ Name *string `json:"name,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for WcfRelay.
+func (wr WcfRelay) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if wr.WcfRelayProperties != nil {
+ objectMap["properties"] = wr.WcfRelayProperties
+ }
+ if wr.ID != nil {
+ objectMap["id"] = wr.ID
+ }
+ if wr.Name != nil {
+ objectMap["name"] = wr.Name
+ }
+ if wr.Type != nil {
+ objectMap["type"] = wr.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for WcfRelay struct.
+func (wr *WcfRelay) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var wcfRelayProperties WcfRelayProperties
+ err = json.Unmarshal(*v, &wcfRelayProperties)
+ if err != nil {
+ return err
+ }
+ wr.WcfRelayProperties = &wcfRelayProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ wr.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ wr.Name = &name
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ wr.Type = &typeVar
+ }
+ }
+ }
+
+ return nil
+}
+
+// WcfRelayProperties properties of the WCF relay.
+type WcfRelayProperties struct {
+ // IsDynamic - Returns true if the relay is dynamic; otherwise, false.
+ IsDynamic *bool `json:"isDynamic,omitempty"`
+ // CreatedAt - The time the WCF relay was created.
+ CreatedAt *date.Time `json:"createdAt,omitempty"`
+ // UpdatedAt - The time the namespace was updated.
+ UpdatedAt *date.Time `json:"updatedAt,omitempty"`
+ // ListenerCount - The number of listeners for this relay. Note that min :1 and max:25 are supported.
+ ListenerCount *int32 `json:"listenerCount,omitempty"`
+ // RelayType - WCF relay type. Possible values include: 'NetTCP', 'HTTP'
+ RelayType RelaytypeEnum `json:"relayType,omitempty"`
+ // RequiresClientAuthorization - Returns true if client authorization is needed for this relay; otherwise, false.
+ RequiresClientAuthorization *bool `json:"requiresClientAuthorization,omitempty"`
+ // RequiresTransportSecurity - Returns true if transport security is needed for this relay; otherwise, false.
+ RequiresTransportSecurity *bool `json:"requiresTransportSecurity,omitempty"`
+ // UserMetadata - The usermetadata is a placeholder to store user-defined string data for the WCF Relay endpoint. For example, it can be used to store descriptive data, such as list of teams and their contact information. Also, user-defined configuration settings can be stored.
+ UserMetadata *string `json:"userMetadata,omitempty"`
+}
+
+// WcfRelaysListResult the response of the list WCF relay operation.
+type WcfRelaysListResult struct {
+ autorest.Response `json:"-"`
+ // Value - Result of the list WCF relay operation.
+ Value *[]WcfRelay `json:"value,omitempty"`
+ // NextLink - Link to the next set of results. Not empty if value contains incomplete list of WCF relays.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// WcfRelaysListResultIterator provides access to a complete listing of WcfRelay values.
+type WcfRelaysListResultIterator struct {
+ i int
+ page WcfRelaysListResultPage
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *WcfRelaysListResultIterator) Next() error {
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err := iter.page.Next()
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter WcfRelaysListResultIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter WcfRelaysListResultIterator) Response() WcfRelaysListResult {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter WcfRelaysListResultIterator) Value() WcfRelay {
+ if !iter.page.NotDone() {
+ return WcfRelay{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (wrlr WcfRelaysListResult) IsEmpty() bool {
+ return wrlr.Value == nil || len(*wrlr.Value) == 0
+}
+
+// wcfRelaysListResultPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (wrlr WcfRelaysListResult) wcfRelaysListResultPreparer() (*http.Request, error) {
+ if wrlr.NextLink == nil || len(to.String(wrlr.NextLink)) < 1 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(wrlr.NextLink)))
+}
+
+// WcfRelaysListResultPage contains a page of WcfRelay values.
+type WcfRelaysListResultPage struct {
+ fn func(WcfRelaysListResult) (WcfRelaysListResult, error)
+ wrlr WcfRelaysListResult
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *WcfRelaysListResultPage) Next() error {
+ next, err := page.fn(page.wrlr)
+ if err != nil {
+ return err
+ }
+ page.wrlr = next
+ return nil
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page WcfRelaysListResultPage) NotDone() bool {
+ return !page.wrlr.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page WcfRelaysListResultPage) Response() WcfRelaysListResult {
+ return page.wrlr
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page WcfRelaysListResultPage) Values() []WcfRelay {
+ if page.wrlr.IsEmpty() {
+ return nil
+ }
+ return *page.wrlr.Value
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/namespaces.go b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/namespaces.go
new file mode 100644
index 000000000000..f1dd78a83e27
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/namespaces.go
@@ -0,0 +1,1144 @@
+package relay
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// NamespacesClient is the use these API to manage Azure Relay resources through Azure Resource Manager.
+type NamespacesClient struct {
+ BaseClient
+}
+
+// NewNamespacesClient creates an instance of the NamespacesClient client.
+func NewNamespacesClient(subscriptionID string) NamespacesClient {
+ return NewNamespacesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewNamespacesClientWithBaseURI creates an instance of the NamespacesClient client.
+func NewNamespacesClientWithBaseURI(baseURI string, subscriptionID string) NamespacesClient {
+ return NamespacesClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CheckNameAvailabilityMethod check the specified namespace name availability.
+// Parameters:
+// parameters - parameters to check availability of the specified namespace name.
+func (client NamespacesClient) CheckNameAvailabilityMethod(ctx context.Context, parameters CheckNameAvailability) (result CheckNameAvailabilityResult, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.Name", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "CheckNameAvailabilityMethod", err.Error())
+ }
+
+ req, err := client.CheckNameAvailabilityMethodPreparer(ctx, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CheckNameAvailabilityMethod", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CheckNameAvailabilityMethodSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CheckNameAvailabilityMethod", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CheckNameAvailabilityMethodResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CheckNameAvailabilityMethod", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CheckNameAvailabilityMethodPreparer prepares the CheckNameAvailabilityMethod request.
+func (client NamespacesClient) CheckNameAvailabilityMethodPreparer(ctx context.Context, parameters CheckNameAvailability) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Relay/checkNameAvailability", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CheckNameAvailabilityMethodSender sends the CheckNameAvailabilityMethod request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) CheckNameAvailabilityMethodSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// CheckNameAvailabilityMethodResponder handles the response to the CheckNameAvailabilityMethod request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) CheckNameAvailabilityMethodResponder(resp *http.Response) (result CheckNameAvailabilityResult, 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 create Azure Relay namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// parameters - parameters supplied to create a namespace resource.
+func (client NamespacesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, namespaceName string, parameters Namespace) (result NamespacesCreateOrUpdateFuture, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.Sku", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, namespaceName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CreateOrUpdate", result.Response(), "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client NamespacesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, namespaceName string, parameters Namespace) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) CreateOrUpdateSender(req *http.Request) (future NamespacesCreateOrUpdateFuture, err error) {
+ sender := autorest.DecorateSender(client, azure.DoRetryWithRegistration(client.Client))
+ future.Future = azure.NewFuture(req)
+ future.req = req
+ _, err = future.Done(sender)
+ if err != nil {
+ return
+ }
+ err = autorest.Respond(future.Response(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated))
+ return
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) CreateOrUpdateResponder(resp *http.Response) (result Namespace, 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
+}
+
+// CreateOrUpdateAuthorizationRule creates or updates an authorization rule for a namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// authorizationRuleName - the authorization rule name.
+// parameters - the authorization rule parameters.
+func (client NamespacesClient) CreateOrUpdateAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string, parameters AuthorizationRule) (result AuthorizationRule, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties.Rights", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties.Rights", Name: validation.UniqueItems, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "CreateOrUpdateAuthorizationRule", err.Error())
+ }
+
+ req, err := client.CreateOrUpdateAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, authorizationRuleName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CreateOrUpdateAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CreateOrUpdateAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "CreateOrUpdateAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateAuthorizationRulePreparer prepares the CreateOrUpdateAuthorizationRule request.
+func (client NamespacesClient) CreateOrUpdateAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string, parameters AuthorizationRule) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) CreateOrUpdateAuthorizationRuleResponder(resp *http.Response) (result AuthorizationRule, 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 an existing namespace. This operation also removes all associated resources under the namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+func (client NamespacesClient) Delete(ctx context.Context, resourceGroupName string, namespaceName string) (result NamespacesDeleteFuture, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "Delete", err.Error())
+ }
+
+ req, err := client.DeletePreparer(ctx, resourceGroupName, namespaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ result, err = client.DeleteSender(req)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Delete", result.Response(), "Failure sending request")
+ return
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client NamespacesClient) DeletePreparer(ctx context.Context, resourceGroupName string, namespaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) DeleteSender(req *http.Request) (future NamespacesDeleteFuture, err error) {
+ sender := autorest.DecorateSender(client, azure.DoRetryWithRegistration(client.Client))
+ future.Future = azure.NewFuture(req)
+ future.req = req
+ _, err = future.Done(sender)
+ if err != nil {
+ return
+ }
+ err = autorest.Respond(future.Response(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent))
+ return
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
+ autorest.ByClosing())
+ result.Response = resp
+ return
+}
+
+// DeleteAuthorizationRule deletes a namespace authorization rule.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// authorizationRuleName - the authorization rule name.
+func (client NamespacesClient) DeleteAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName 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}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "DeleteAuthorizationRule", err.Error())
+ }
+
+ req, err := client.DeleteAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "DeleteAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "DeleteAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "DeleteAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteAuthorizationRulePreparer prepares the DeleteAuthorizationRule request.
+func (client NamespacesClient) DeleteAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) DeleteAuthorizationRuleResponder(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 returns the description for the specified namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+func (client NamespacesClient) Get(ctx context.Context, resourceGroupName string, namespaceName string) (result Namespace, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "Get", err.Error())
+ }
+
+ req, err := client.GetPreparer(ctx, resourceGroupName, namespaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client NamespacesClient) GetPreparer(ctx context.Context, resourceGroupName string, namespaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) GetResponder(resp *http.Response) (result Namespace, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetAuthorizationRule authorization rule for a namespace by name.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// authorizationRuleName - the authorization rule name.
+func (client NamespacesClient) GetAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string) (result AuthorizationRule, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "GetAuthorizationRule", err.Error())
+ }
+
+ req, err := client.GetAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "GetAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "GetAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "GetAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetAuthorizationRulePreparer prepares the GetAuthorizationRule request.
+func (client NamespacesClient) GetAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) GetAuthorizationRuleResponder(resp *http.Response) (result AuthorizationRule, 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 lists all the available namespaces within the subscription regardless of the resourceGroups.
+func (client NamespacesClient) List(ctx context.Context) (result NamespaceListResultPage, err error) {
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.nlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.nlr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client NamespacesClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Relay/namespaces", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) ListResponder(resp *http.Response) (result NamespaceListResult, 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 NamespacesClient) listNextResults(lastResults NamespaceListResult) (result NamespaceListResult, err error) {
+ req, err := lastResults.namespaceListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.NamespacesClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.NamespacesClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client NamespacesClient) ListComplete(ctx context.Context) (result NamespaceListResultIterator, err error) {
+ result.page, err = client.List(ctx)
+ return
+}
+
+// ListAuthorizationRules authorization rules for a namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+func (client NamespacesClient) ListAuthorizationRules(ctx context.Context, resourceGroupName string, namespaceName string) (result AuthorizationRuleListResultPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "ListAuthorizationRules", err.Error())
+ }
+
+ result.fn = client.listAuthorizationRulesNextResults
+ req, err := client.ListAuthorizationRulesPreparer(ctx, resourceGroupName, namespaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListAuthorizationRules", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAuthorizationRulesSender(req)
+ if err != nil {
+ result.arlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListAuthorizationRules", resp, "Failure sending request")
+ return
+ }
+
+ result.arlr, err = client.ListAuthorizationRulesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListAuthorizationRules", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListAuthorizationRulesPreparer prepares the ListAuthorizationRules request.
+func (client NamespacesClient) ListAuthorizationRulesPreparer(ctx context.Context, resourceGroupName string, namespaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/authorizationRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) ListAuthorizationRulesResponder(resp *http.Response) (result AuthorizationRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAuthorizationRulesNextResults retrieves the next set of results, if any.
+func (client NamespacesClient) listAuthorizationRulesNextResults(lastResults AuthorizationRuleListResult) (result AuthorizationRuleListResult, err error) {
+ req, err := lastResults.authorizationRuleListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.NamespacesClient", "listAuthorizationRulesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAuthorizationRulesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.NamespacesClient", "listAuthorizationRulesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAuthorizationRulesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "listAuthorizationRulesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAuthorizationRulesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client NamespacesClient) ListAuthorizationRulesComplete(ctx context.Context, resourceGroupName string, namespaceName string) (result AuthorizationRuleListResultIterator, err error) {
+ result.page, err = client.ListAuthorizationRules(ctx, resourceGroupName, namespaceName)
+ return
+}
+
+// ListByResourceGroup lists all the available namespaces within the ResourceGroup.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+func (client NamespacesClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result NamespaceListResultPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "ListByResourceGroup", err.Error())
+ }
+
+ result.fn = client.listByResourceGroupNextResults
+ req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.nlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result.nlr, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client NamespacesClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) ListByResourceGroupResponder(resp *http.Response) (result NamespaceListResult, 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 NamespacesClient) listByResourceGroupNextResults(lastResults NamespaceListResult) (result NamespaceListResult, err error) {
+ req, err := lastResults.namespaceListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.NamespacesClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.NamespacesClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
+func (client NamespacesClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result NamespaceListResultIterator, err error) {
+ result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
+ return
+}
+
+// ListKeys primary and secondary connection strings to the namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// authorizationRuleName - the authorization rule name.
+func (client NamespacesClient) ListKeys(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string) (result AccessKeys, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "ListKeys", err.Error())
+ }
+
+ req, err := client.ListKeysPreparer(ctx, resourceGroupName, namespaceName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "ListKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListKeysPreparer prepares the ListKeys request.
+func (client NamespacesClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-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.Relay/namespaces/{namespaceName}/authorizationRules/{authorizationRuleName}/listKeys", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListKeysSender sends the ListKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) ListKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListKeysResponder handles the response to the ListKeys request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) ListKeysResponder(resp *http.Response) (result AccessKeys, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RegenerateKeys regenerates the primary or secondary connection strings to the namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// authorizationRuleName - the authorization rule name.
+// parameters - parameters supplied to regenerate authorization rule.
+func (client NamespacesClient) RegenerateKeys(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string, parameters RegenerateAccessKeyParameters) (result AccessKeys, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "RegenerateKeys", err.Error())
+ }
+
+ req, err := client.RegenerateKeysPreparer(ctx, resourceGroupName, namespaceName, authorizationRuleName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "RegenerateKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RegenerateKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "RegenerateKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RegenerateKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "RegenerateKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RegenerateKeysPreparer prepares the RegenerateKeys request.
+func (client NamespacesClient) RegenerateKeysPreparer(ctx context.Context, resourceGroupName string, namespaceName string, authorizationRuleName string, parameters RegenerateAccessKeyParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/authorizationRules/{authorizationRuleName}/regenerateKeys", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RegenerateKeysSender sends the RegenerateKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) RegenerateKeysResponder(resp *http.Response) (result AccessKeys, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// Update creates or updates a namespace. Once created, this namespace's resource manifest is immutable. This operation
+// is idempotent.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// parameters - parameters for updating a namespace resource.
+func (client NamespacesClient) Update(ctx context.Context, resourceGroupName string, namespaceName string, parameters UpdateParameters) (result Namespace, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.NamespacesClient", "Update", err.Error())
+ }
+
+ req, err := client.UpdatePreparer(ctx, resourceGroupName, namespaceName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Update", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.UpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Update", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.UpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.NamespacesClient", "Update", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// UpdatePreparer prepares the Update request.
+func (client NamespacesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, namespaceName string, parameters UpdateParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPatch(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// UpdateSender sends the Update request. The method will close the
+// http.Response Body if it receives an error.
+func (client NamespacesClient) UpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// UpdateResponder handles the response to the Update request. The method always
+// closes the http.Response Body.
+func (client NamespacesClient) UpdateResponder(resp *http.Response) (result Namespace, 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
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/operations.go b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/operations.go
new file mode 100644
index 000000000000..9046fe485976
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/operations.go
@@ -0,0 +1,126 @@
+package relay
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "net/http"
+)
+
+// OperationsClient is the use these API to manage Azure Relay resources through Azure Resource Manager.
+type OperationsClient struct {
+ BaseClient
+}
+
+// NewOperationsClient creates an instance of the OperationsClient client.
+func NewOperationsClient(subscriptionID string) OperationsClient {
+ return NewOperationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewOperationsClientWithBaseURI creates an instance of the OperationsClient client.
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+ return OperationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// List lists all available Relay REST API operations.
+func (client OperationsClient) List(ctx context.Context) (result OperationListResultPage, err error) {
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.OperationsClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.olr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.OperationsClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.olr, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.OperationsClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPath("/providers/Microsoft.Relay/operations"),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client OperationsClient) ListResponder(resp *http.Response) (result OperationListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ 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 OperationsClient) listNextResults(lastResults OperationListResult) (result OperationListResult, err error) {
+ req, err := lastResults.operationListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.OperationsClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.OperationsClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.OperationsClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client OperationsClient) ListComplete(ctx context.Context) (result OperationListResultIterator, err error) {
+ result.page, err = client.List(ctx)
+ return
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/version.go b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/version.go
new file mode 100644
index 000000000000..fed5c9635937
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/version.go
@@ -0,0 +1,30 @@
+package relay
+
+import "github.com/Azure/azure-sdk-for-go/version"
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// UserAgent returns the UserAgent string to use when sending http.Requests.
+func UserAgent() string {
+ return "Azure-SDK-For-Go/" + version.Number + " relay/2017-04-01"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+ return version.Number
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/wcfrelays.go b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/wcfrelays.go
new file mode 100644
index 000000000000..37b5a7a20a68
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay/wcfrelays.go
@@ -0,0 +1,942 @@
+package relay
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// WCFRelaysClient is the use these API to manage Azure Relay resources through Azure Resource Manager.
+type WCFRelaysClient struct {
+ BaseClient
+}
+
+// NewWCFRelaysClient creates an instance of the WCFRelaysClient client.
+func NewWCFRelaysClient(subscriptionID string) WCFRelaysClient {
+ return NewWCFRelaysClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewWCFRelaysClientWithBaseURI creates an instance of the WCFRelaysClient client.
+func NewWCFRelaysClientWithBaseURI(baseURI string, subscriptionID string) WCFRelaysClient {
+ return WCFRelaysClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// CreateOrUpdate creates or updates a WCF relay. This operation is idempotent.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+// parameters - parameters supplied to create a WCF relay.
+func (client WCFRelaysClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, parameters WcfRelay) (result WcfRelay, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.WcfRelayProperties", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.WcfRelayProperties.ListenerCount", Name: validation.Null, Rule: false,
+ Chain: []validation.Constraint{{Target: "parameters.WcfRelayProperties.ListenerCount", Name: validation.InclusiveMaximum, Rule: 25, Chain: nil},
+ {Target: "parameters.WcfRelayProperties.ListenerCount", Name: validation.InclusiveMinimum, Rule: 0, Chain: nil},
+ }},
+ }}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "CreateOrUpdate", err.Error())
+ }
+
+ req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, namespaceName, relayName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "CreateOrUpdate", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "CreateOrUpdate", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "CreateOrUpdate", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
+func (client WCFRelaysClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, parameters WcfRelay) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) CreateOrUpdateResponder(resp *http.Response) (result WcfRelay, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// CreateOrUpdateAuthorizationRule creates or updates an authorization rule for a WCF relay.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+// authorizationRuleName - the authorization rule name.
+// parameters - the authorization rule parameters.
+func (client WCFRelaysClient) CreateOrUpdateAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string, parameters AuthorizationRule) (result AuthorizationRule, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: parameters,
+ Constraints: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties.Rights", Name: validation.Null, Rule: true,
+ Chain: []validation.Constraint{{Target: "parameters.AuthorizationRuleProperties.Rights", Name: validation.UniqueItems, Rule: true, Chain: nil}}},
+ }}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "CreateOrUpdateAuthorizationRule", err.Error())
+ }
+
+ req, err := client.CreateOrUpdateAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, relayName, authorizationRuleName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "CreateOrUpdateAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.CreateOrUpdateAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "CreateOrUpdateAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.CreateOrUpdateAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "CreateOrUpdateAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// CreateOrUpdateAuthorizationRulePreparer prepares the CreateOrUpdateAuthorizationRule request.
+func (client WCFRelaysClient) CreateOrUpdateAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string, parameters AuthorizationRule) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPut(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// CreateOrUpdateAuthorizationRuleSender sends the CreateOrUpdateAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) CreateOrUpdateAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// CreateOrUpdateAuthorizationRuleResponder handles the response to the CreateOrUpdateAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) CreateOrUpdateAuthorizationRuleResponder(resp *http.Response) (result AuthorizationRule, 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 WCF relay.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+func (client WCFRelaysClient) Delete(ctx context.Context, resourceGroupName 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}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "Delete", err.Error())
+ }
+
+ req, err := client.DeletePreparer(ctx, resourceGroupName, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "Delete", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "Delete", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "Delete", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeletePreparer prepares the Delete request.
+func (client WCFRelaysClient) DeletePreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteSender sends the Delete request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) DeleteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// DeleteResponder handles the response to the Delete request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) 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
+}
+
+// DeleteAuthorizationRule deletes a WCF relay authorization rule.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+// authorizationRuleName - the authorization rule name.
+func (client WCFRelaysClient) DeleteAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName 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}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "DeleteAuthorizationRule", err.Error())
+ }
+
+ req, err := client.DeleteAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, relayName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "DeleteAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.DeleteAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = resp
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "DeleteAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.DeleteAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "DeleteAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// DeleteAuthorizationRulePreparer prepares the DeleteAuthorizationRule request.
+func (client WCFRelaysClient) DeleteAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// DeleteAuthorizationRuleSender sends the DeleteAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) DeleteAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// DeleteAuthorizationRuleResponder handles the response to the DeleteAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) DeleteAuthorizationRuleResponder(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 returns the description for the specified WCF relay.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+func (client WCFRelaysClient) Get(ctx context.Context, resourceGroupName string, namespaceName string, relayName string) (result WcfRelay, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "Get", err.Error())
+ }
+
+ req, err := client.GetPreparer(ctx, resourceGroupName, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "Get", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "Get", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "Get", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetPreparer prepares the Get request.
+func (client WCFRelaysClient) GetPreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetSender sends the Get request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) GetSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetResponder handles the response to the Get request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) GetResponder(resp *http.Response) (result WcfRelay, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetAuthorizationRule get authorizationRule for a WCF relay by name.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+// authorizationRuleName - the authorization rule name.
+func (client WCFRelaysClient) GetAuthorizationRule(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string) (result AuthorizationRule, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "GetAuthorizationRule", err.Error())
+ }
+
+ req, err := client.GetAuthorizationRulePreparer(ctx, resourceGroupName, namespaceName, relayName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "GetAuthorizationRule", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetAuthorizationRuleSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "GetAuthorizationRule", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetAuthorizationRuleResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "GetAuthorizationRule", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetAuthorizationRulePreparer prepares the GetAuthorizationRule request.
+func (client WCFRelaysClient) GetAuthorizationRulePreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}/authorizationRules/{authorizationRuleName}", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetAuthorizationRuleSender sends the GetAuthorizationRule request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) GetAuthorizationRuleSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetAuthorizationRuleResponder handles the response to the GetAuthorizationRule request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) GetAuthorizationRuleResponder(resp *http.Response) (result AuthorizationRule, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// ListAuthorizationRules authorization rules for a WCF relay.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+func (client WCFRelaysClient) ListAuthorizationRules(ctx context.Context, resourceGroupName string, namespaceName string, relayName string) (result AuthorizationRuleListResultPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "ListAuthorizationRules", err.Error())
+ }
+
+ result.fn = client.listAuthorizationRulesNextResults
+ req, err := client.ListAuthorizationRulesPreparer(ctx, resourceGroupName, namespaceName, relayName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListAuthorizationRules", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListAuthorizationRulesSender(req)
+ if err != nil {
+ result.arlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListAuthorizationRules", resp, "Failure sending request")
+ return
+ }
+
+ result.arlr, err = client.ListAuthorizationRulesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListAuthorizationRules", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListAuthorizationRulesPreparer prepares the ListAuthorizationRules request.
+func (client WCFRelaysClient) ListAuthorizationRulesPreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}/authorizationRules", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListAuthorizationRulesSender sends the ListAuthorizationRules request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) ListAuthorizationRulesSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListAuthorizationRulesResponder handles the response to the ListAuthorizationRules request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) ListAuthorizationRulesResponder(resp *http.Response) (result AuthorizationRuleListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listAuthorizationRulesNextResults retrieves the next set of results, if any.
+func (client WCFRelaysClient) listAuthorizationRulesNextResults(lastResults AuthorizationRuleListResult) (result AuthorizationRuleListResult, err error) {
+ req, err := lastResults.authorizationRuleListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "listAuthorizationRulesNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListAuthorizationRulesSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "listAuthorizationRulesNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListAuthorizationRulesResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "listAuthorizationRulesNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListAuthorizationRulesComplete enumerates all values, automatically crossing page boundaries as required.
+func (client WCFRelaysClient) ListAuthorizationRulesComplete(ctx context.Context, resourceGroupName string, namespaceName string, relayName string) (result AuthorizationRuleListResultIterator, err error) {
+ result.page, err = client.ListAuthorizationRules(ctx, resourceGroupName, namespaceName, relayName)
+ return
+}
+
+// ListByNamespace lists the WCF relays within the namespace.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+func (client WCFRelaysClient) ListByNamespace(ctx context.Context, resourceGroupName string, namespaceName string) (result WcfRelaysListResultPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "ListByNamespace", err.Error())
+ }
+
+ result.fn = client.listByNamespaceNextResults
+ req, err := client.ListByNamespacePreparer(ctx, resourceGroupName, namespaceName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListByNamespace", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByNamespaceSender(req)
+ if err != nil {
+ result.wrlr.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListByNamespace", resp, "Failure sending request")
+ return
+ }
+
+ result.wrlr, err = client.ListByNamespaceResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListByNamespace", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByNamespacePreparer prepares the ListByNamespace request.
+func (client WCFRelaysClient) ListByNamespacePreparer(ctx context.Context, resourceGroupName string, namespaceName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-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.Relay/namespaces/{namespaceName}/wcfRelays", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByNamespaceSender sends the ListByNamespace request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) ListByNamespaceSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByNamespaceResponder handles the response to the ListByNamespace request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) ListByNamespaceResponder(resp *http.Response) (result WcfRelaysListResult, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByNamespaceNextResults retrieves the next set of results, if any.
+func (client WCFRelaysClient) listByNamespaceNextResults(lastResults WcfRelaysListResult) (result WcfRelaysListResult, err error) {
+ req, err := lastResults.wcfRelaysListResultPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "listByNamespaceNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByNamespaceSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "listByNamespaceNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByNamespaceResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "listByNamespaceNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByNamespaceComplete enumerates all values, automatically crossing page boundaries as required.
+func (client WCFRelaysClient) ListByNamespaceComplete(ctx context.Context, resourceGroupName string, namespaceName string) (result WcfRelaysListResultIterator, err error) {
+ result.page, err = client.ListByNamespace(ctx, resourceGroupName, namespaceName)
+ return
+}
+
+// ListKeys primary and secondary connection strings to the WCF relay.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+// authorizationRuleName - the authorization rule name.
+func (client WCFRelaysClient) ListKeys(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string) (result AccessKeys, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "ListKeys", err.Error())
+ }
+
+ req, err := client.ListKeysPreparer(ctx, resourceGroupName, namespaceName, relayName, authorizationRuleName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.ListKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "ListKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListKeysPreparer prepares the ListKeys request.
+func (client WCFRelaysClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-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.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}/authorizationRules/{authorizationRuleName}/listKeys", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListKeysSender sends the ListKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) ListKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListKeysResponder handles the response to the ListKeys request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) ListKeysResponder(resp *http.Response) (result AccessKeys, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// RegenerateKeys regenerates the primary or secondary connection strings to the WCF relay.
+// Parameters:
+// resourceGroupName - name of the Resource group within the Azure subscription.
+// namespaceName - the namespace name
+// relayName - the relay name.
+// authorizationRuleName - the authorization rule name.
+// parameters - parameters supplied to regenerate authorization rule.
+func (client WCFRelaysClient) RegenerateKeys(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string, parameters RegenerateAccessKeyParameters) (result AccessKeys, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: namespaceName,
+ Constraints: []validation.Constraint{{Target: "namespaceName", Name: validation.MaxLength, Rule: 50, Chain: nil},
+ {Target: "namespaceName", Name: validation.MinLength, Rule: 6, Chain: nil}}},
+ {TargetValue: relayName,
+ Constraints: []validation.Constraint{{Target: "relayName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
+ {TargetValue: authorizationRuleName,
+ Constraints: []validation.Constraint{{Target: "authorizationRuleName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("relay.WCFRelaysClient", "RegenerateKeys", err.Error())
+ }
+
+ req, err := client.RegenerateKeysPreparer(ctx, resourceGroupName, namespaceName, relayName, authorizationRuleName, parameters)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "RegenerateKeys", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.RegenerateKeysSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "RegenerateKeys", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.RegenerateKeysResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "relay.WCFRelaysClient", "RegenerateKeys", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// RegenerateKeysPreparer prepares the RegenerateKeys request.
+func (client WCFRelaysClient) RegenerateKeysPreparer(ctx context.Context, resourceGroupName string, namespaceName string, relayName string, authorizationRuleName string, parameters RegenerateAccessKeyParameters) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "authorizationRuleName": autorest.Encode("path", authorizationRuleName),
+ "namespaceName": autorest.Encode("path", namespaceName),
+ "relayName": autorest.Encode("path", relayName),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2017-04-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsContentType("application/json; charset=utf-8"),
+ autorest.AsPost(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Relay/namespaces/{namespaceName}/wcfRelays/{relayName}/authorizationRules/{authorizationRuleName}/regenerateKeys", pathParameters),
+ autorest.WithJSON(parameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// RegenerateKeysSender sends the RegenerateKeys request. The method will close the
+// http.Response Body if it receives an error.
+func (client WCFRelaysClient) RegenerateKeysSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// RegenerateKeysResponder handles the response to the RegenerateKeys request. The method always
+// closes the http.Response Body.
+func (client WCFRelaysClient) RegenerateKeysResponder(resp *http.Response) (result AccessKeys, 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/vendor.json b/vendor/vendor.json
index f7f29678221b..f05e53de3058 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -194,6 +194,14 @@
"version": "v16.2.1",
"versionExact": "v16.2.1"
},
+ {
+ "checksumSHA1": "/Tlgqs81ToI+zz4miZcfu5yvZYU=",
+ "path": "github.com/Azure/azure-sdk-for-go/services/relay/mgmt/2017-04-01/relay",
+ "revision": "4650843026a7fdec254a8d9cf893693a254edd0b",
+ "revisionTime": "2018-05-04T19:14:26Z",
+ "version": "v16.2.1",
+ "versionExact": "v16.2.1"
+ },
{
"checksumSHA1": "DJY5zDEcGa82/Hbfud8lgHCuvU4=",
"path": "github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions",
diff --git a/website/azurerm.erb b/website/azurerm.erb
index 8a205cdae715..7d118afd0049 100644
--- a/website/azurerm.erb
+++ b/website/azurerm.erb
@@ -526,6 +526,10 @@
azurerm_iothub
+ >
+ azurerm_relay_namespace
+
+
>
azurerm_servicebus_namespace
diff --git a/website/docs/r/relay_namespace.html.markdown b/website/docs/r/relay_namespace.html.markdown
new file mode 100644
index 000000000000..8dfc02ead48b
--- /dev/null
+++ b/website/docs/r/relay_namespace.html.markdown
@@ -0,0 +1,82 @@
+---
+layout: "azurerm"
+page_title: "Azure Resource Manager: azurerm_relay_namespace"
+sidebar_current: "docs-azurerm-resource-relay-namespace"
+description: |-
+ Manages an Azure Relay Namespace.
+
+---
+
+# azurerm_relay_namespace
+
+Manages an Azure Relay Namespace.
+
+## Example Usage
+
+```hcl
+resource "azurerm_resource_group" "test" {
+ name = "example-resources"
+ location = "West Europe"
+}
+
+resource "azurerm_relay_namespace" "test" {
+ name = "example-relay"
+ location = "${azurerm_resource_group.test.location}"
+ resource_group_name = "${azurerm_resource_group.test.name}"
+ sku {
+ name = "Standard"
+ }
+
+ tags {
+ source = "terraform"
+ }
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `name` - (Required) Specifies the name of the Azure Relay Namespace. Changing this forces a new resource to be created.
+
+* `resource_group_name` - (Required) The name of the resource group in which to create the Azure Relay Namespace.
+
+* `location` - (Required) Specifies the supported Azure location where the Azure Relay Namespace exists. Changing this forces a new resource to be created.
+
+* `sku` - (Required) A `sku` block as defined below.
+
+* `tags` - (Optional) A mapping of tags to assign to the resource.
+
+---
+
+A `sku` block contains:
+
+* `name` - (Required) The name of the SKU to use. At this time the only supported value is `Standard`.
+
+
+## Attributes Reference
+
+The following attributes are exported:
+
+* `id` - The Azure Relay Namespace ID.
+
+The following attributes are exported only if there is an authorization rule named
+`RootManageSharedAccessKey` which is created automatically by Azure.
+
+* `primary_connection_string` - The primary connection string for the authorization rule `RootManageSharedAccessKey`.
+
+* `secondary_connection_string` - The secondary connection string for the authorization rule `RootManageSharedAccessKey`.
+
+* `primary_key` - The primary access key for the authorization rule `RootManageSharedAccessKey`.
+
+* `secondary_key` - The secondary access key for the authorization rule `RootManageSharedAccessKey`.
+
+* `metric_id` - The Identifier for Azure Insights metrics.
+
+## Import
+
+Azure Relay Namespace's can be imported using the `resource id`, e.g.
+
+```shell
+terraform import azurerm_relay_namespace.relay1 /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Relay/namespaces/relay1
+```